How 15 Years of Repetition Became The Blueprint For My Software

A few years ago, if you had asked me how I came up with ideas for products, I probably would have given you a terrible answer.

I would have talked about market research.

Trends.

Opportunities.

Demand.

Today, I have a much simpler answer.

I build products based on things that made me struggle.

That might sound dramatic.

But after spending more than fifteen years building websites, digital products, and businesses for other people, I’ve realized something important:

The problems that keep hurting you year after year are probably the problems you’re supposed to solve.

And that’s exactly what I’m trying to do.

I never wanted to build software just to build software

I’ve always loved building things.

That’s one of the reasons I became a developer.

I loved the idea that you could sit in front of a computer, create something from nothing, and watch it become real.

But over time, I realized that I wasn’t excited by technology itself.

I was excited by solving problems.

For most of my career, I was solving real problems inside client and agency projects.

Client problems.

Agency problems.

Company problems.

Business problems that taught me how websites and digital products are built.

But after fifteen years, I started asking myself a difficult question:

If I’ve spent this much time solving these problems, why do I still feel the struggle on every project?

The same frustrations kept coming back

No matter how much experience I gained, certain problems never disappeared.

Every new project started with the same questions.

Where do I begin?

How should I structure this?

Which stack should I use?

Which design decisions should I make?

How do I avoid rebuilding the same thing for the hundredth time?

At first, I thought this was just part of the job.

Then I realized that everyone around me was struggling with the same things.

Agencies.

Freelancers.

Developers.

Founders.

Everyone was reinventing the wheel, jumping onto the next trend or tool.

Again.

And again.

I spent years optimizing the wrong thing

Like many developers, I spent years trying to optimize the workflow trying the next shiny trend.

Better frameworks.

Better tools.

Better architectures.

But eventually, I realized that it was just creating more stress.

Then I started paying attention to my frustrations

So, during my biggest burnout, which lasted for about one year, I had a deep introspection to understand if it was my job that was wrong or something inside of my workflow.

That led me to one big realization.

It wasn’t the work itself.

It was the constant repetition.

Every project required hundreds of decisions.

Sometimes thousands.

Not because they were important.

Because nobody had created systems to avoid making them.

I was tired of making the same decisions over and over again.

So at some point, I changed the way I looked at problems.

Instead of asking:

How do I solve this for this project?

I started asking:

Why does this problem keep existing?

That simple shift changed everything.

Because once you notice recurring frustration, you start seeing more opportunities.

The thing that annoys you every day might actually be a product.

The thing that drains your energy every week might actually be a business.

The thing that you’ve accepted as normal might be exactly what needs to be fixed.

Recurring frustrations are often signals worth investigating. Sometimes they’re just part of the work. But sometimes they’re pointing at a product that doesn’t exist yet.

Themerson started with that exhaustion

One of the products I’m building today is called Themerson.

If you ask me where the idea came from… the answer is simple.

I got tired.

Not tired of designing.

Not tired of building websites.

Tired of rebuilding foundations every single time.

Spacing systems.

Typography systems.

Color systems.

Design tokens.

Theme structures.

Component decisions.

The work itself wasn’t difficult.

The repetition was.

After years of doing the same mental work over and over, I started asking myself:

Why does every project still begin with the same decisions?

Themerson is my attempt to answer that question.

For years, I watched agencies and freelancers build websites from scratch.

Every project.

Every client.

Every time.

The same discovery calls.

The same wireframes.

The same page structures.

The same business questions.

The same strategic decisions.

Everyone was working hard.

Very few people were building systems.

I experienced that chaos myself for years.

Eventually, I stopped asking:

How do I make this work less repetitive?

And started asking:

Why are we still working like this?

That question eventually became the foundation for a new WordPress platform.

I’ve stopped looking for markets

One of the most common startup suggestion is:

Find a market.

I understand why people say that.

But personally, I’ve found something else to be more useful.

Find a scar.

Find something that frustrated you for years.

Find something that cost you money.

Find something that drained your energy.

Find something that made you say:

There has to be a better way.

Because if you’ve experienced that problem deeply enough, chances are that thousands of other people have too.

And unlike market research, pain creates clarity.

I’m not building products because they sound exciting

I’m building products because I’m trying to solve problems that affected my own life.

Problems that created stress.

Problems that created burnout.

Problems that made me question why this work still required so much repeated effort.

In many ways, every product I’m building is a response to a younger version of myself.

The developer.

The freelancer.

The consultant.

The founder.

The person who spent years believing that working harder would eventually solve everything.

It didn’t.

Building better systems might.

Will these products be useful?

Honestly, I don’t know.

Maybe they will.

Maybe they won’t.

I’m still building.

I’m still learning.

I’m still making mistakes.

But for the first time in a very long time, I feel like I’m building things for the right reasons.

Not only because somebody paid me.

Not because a market report told me to.

Not because a trend appeared.

Because I experienced a problem.

And I want to make sure that other people don’t have to experience the same.

Final thoughts

If there’s one thing I’ve learned after fifteen years of building things, it’s this:

Pay attention to the problems that keep following you.

The frustrations that never disappear.

The work that drains your energy.

The tasks that make you ask:

Why are we still doing this?

Because sometimes, your biggest frustrations aren’t obstacles.

Sometimes, they’re the blueprint for everything you’re supposed to build next.