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 suffer.

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.

The problem was that for most of my career, I was solving somebody else’s problems.

Client problems.

Agency problems.

Company problems.

Business problems that disappeared the moment the invoice was paid.

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

If I’ve spent this much time solving problems, why am I still suffering from the same ones?

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.

Again.

And again.

I spent years optimizing the wrong thing

Like many developers, I spent years trying to optimize technology.

Better frameworks.

Better workflows.

Better tools.

Better architectures.

But eventually, I realized that technology wasn’t the thing creating most of my stress.

Decision-making was.

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 I had to make the same decisions over and over again.

Then I started paying attention to my frustrations

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 opportunities everywhere.

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.

Themerson started with exhaustion

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

People sometimes 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.

The WordPress platform started with frustration

Another product I’m building comes from a different type of frustration.

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 work faster?

And started asking:

Why are we still working like this?

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

My content tool started with another problem

Then there is my content abundance tool.

Which, once again, started with frustration.

I love writing.

I hate repeating myself.

Like many people building products online, I realized that creating content wasn’t actually the hard part.

The hard part was turning one idea into fifty pieces of content.

One article becomes:

a LinkedIn post;
an X thread;
an Instagram carousel;
a newsletter;
a short video;
a quote;
a social post;
another social post.

The work wasn’t creating ideas.

The work was manually transforming the same idea over and over again.

So once again, I asked myself:

Why am I still doing this manually?

And that question became another product.

I’ve stopped looking for markets

One of the most common startup lessons 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 whether I wanted to continue doing this work at all.

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 succeed?

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 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 it for years too.

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.