I Almost Became a Designer

My Journey so far as a software engineer

April 2, 2025updated Apr 2, 2025

I started programming because I liked seeing things change. HTML and CSS gave me instant visual feedback. Write code, see the result. That feedback loop was addictive. It felt like control, like I could bring ideas to life in real time.

For years, that's all I wanted. I'd spend hours tweaking layouts, breaking them, studying how other sites worked, rebuilding them from scratch. I was obsessed with perfection. Tailwind became my playground. I wasn't really learning to code; I was learning to make things look like they were coded well.

And I was good at it. Good enough that I convinced myself that's what engineering was beautiful interfaces, smooth animations, pixel-perfect design. That's where I'd stay.

But there was something I was running from.

Every time I hit a problem that required real logic, not just layout, I'd freeze. Loops, conditionals, problem-solving; These things terrified me. I'd struggled with them early on, and every time I got stuck, I reinforced the same belief: I'm not good at this. So I made a choice. I'd stay in the visual realm, where I felt competent.

I learned JavaScript, React, Next.js, TypeScript. I picked them up quickly because I used them to build interfaces, not to understand systems. And when I didn't understand something, I had AI, Stackoverflow, Medium and Youtube. Sometimes as a crutch, sometimes because I genuinely didn't trust myself to figure it out alone.

That doubt followed me everywhere. If this breaks, can I actually fix it? I'd ship things, but I never felt like I truly owned them.

The breaking point came quietly.

I was watching other developers ship real products; Functional, scalable, confident. Not perfect. Just... real. And I realized I had been spending all my time making things look good while avoiding the actual work of making them work.

So I tried to shift. I started building real applications. But I brought the same intensity to them that I had brought to design. I'd overwork them, refine them obsessively, adjust every detail. I did not abandon projects; I polished them until they're flawless (or until I'm exhausted), felt like mission impossible. Part of that was a genuine desire for quality. Part of it was fear that if you look too closely, you'd see that I did not actually understand what I built or perhaps wrote junk code.

What I learned from building obsessively

Repetition didn’t build understanding, it kept me in a loop.

I kept doing the same thing in slightly different ways, chasing a better version of the same idea instead of moving forward. It looked like progress, but it wasn’t. It delayed shipping. It delayed feedback. It delayed growth.

Underneath that was fear.

If something shipped, someone could see it. If someone saw it, they could point out flaws. And if they pointed out flaws, it would confirm what I already suspected, that I didn’t fully understand what I had built.

So I stayed in the loop: refine, adjust, redesign.

But that’s not engineering.

Engineering is making things work first. Shipping something minimal, with core features. Letting it be imperfect. Then improving it over time, refining, scaling, and learning from real usage.

That shift from hiding in repetition to shipping and iterating is a skill I’m still learning.

Most of what I build starts the same way: I use a product, notice friction, and decide to rebuild it the way I think it should work and look.

So I do. I rebuild it cleaner, simpler, more aligned with how I want it to behave. And then I assume others will want it that way too.

But that’s where things break.

I don’t make noise about it. I keep refining, adjusting, trying to make it flawless before anyone else sees it. Imposter syndrome fills in the gaps,"what if it’s not actually better? what if it breaks? what if people see the flaws?"

So the project sits.

A pastebin that I believe is better than most others barely used. A minimal task system inspired by tools like Linear used only by me. Ideas get built. Then paused. Then replaced by new ideas. Then paused again.

It becomes a loop: build → doubt → refine → repeat. Not because the ideas are bad but because they’re never allowed to be imperfect in public.

Right now, I'm different.

I'm not chasing perfect systems anymore. I'm learning to build systems that actually work, to understand the logic behind every line I write, to care about structure and scalability as much as I care about how things look.

I love design, especially minimal, uncomplicated interfaces but I’m more drawn to functionality: building data-intensive systems that don’t just scale, but thrive under pressure.