I Built Liberonym in Two Months. Alone. With No Technical Background.

Liberonym went from an idea to a live product in two months.

I built it by myself. No co-founder, no employees, no developers and no traditional product or engineering team. When I started on August 2, I had no software-development background. I had never built anything like this before.

But the idea itself is much older.

My background is in trademark law, and later I became an entrepreneur. For years I had seen people make the same mistake with names. Someone likes a name, buys the domain, creates the logo and social accounts, starts marketing and sometimes even registers the company. Then, after all this commitment, they discover something they should probably have known at the beginning.

I kept thinking about one question:

What should someone actually know before committing to a name?

I understood the problem very well. I just didn’t know how to build the software to solve it.

The idea before the software

Liberonym wasn’t an idea that AI gave me. I had carried versions of it for years.

I had spent years studying and practising trademark law, and years building businesses of my own. So I had experienced naming from both sides: advising people about trademarks and brand risks, and choosing names myself as an entrepreneur. Sometimes I made good decisions, and sometimes I learned from bad ones.

But knowing the problem doesn’t mean you know how to build the solution.

I had tried discussing the idea with developers before. The problem wasn’t that they couldn’t build software. The problem was getting what was in my head into theirs. I would explain what I wanted, wait, see what was built, realise it wasn’t quite what I meant, explain again and wait again.

When you’ve accumulated years of knowledge about something, you don’t always realise how much of it is sitting in your head until you try to explain it to somebody else.

So I kept postponing the idea. I never really abandoned it, but building it always felt like a much bigger project than I was ready to take on.

AI changed that.

Suddenly I could explain something and see it in front of me almost immediately. If it wasn’t what I meant, I could say so and change it again. I didn’t have to transfer everything I knew to another person before I could start seeing the product.

AI didn’t give me the idea or teach me what matters about trademarks, names or businesses. What it did was help me turn what I already knew into software.

Before AI, I had to explain Liberonym to someone who understood code. With AI, I could work directly on Liberonym while AI helped me understand and build the software.

That is probably why Liberonym exists today instead of being another idea I kept postponing.

What building it actually felt like

I started building on August 2, and the speed at the beginning was honestly difficult to believe. I could describe something in the morning and sometimes see it working that afternoon.

There were moments when I thought: how is this even possible?

But there was another side to it.

There were days when the AI tools I depended on simply stopped working properly and I couldn’t do much. One day I could move incredibly fast, and the next I could be stuck because the technology that was allowing me to build had itself become the problem.

The most frustrating thing was probably when I finally got something right, asked AI to fix something completely unrelated, and then discovered that it had broken the first thing again.

This happened many times.

And because I had no software-development background, especially at the beginning, I depended heavily on what the AI told me. If it said something had been fixed, tested and published, naturally I wanted to believe it.

I learned not to.

AI can tell you very confidently that something is fixed when it isn’t. It can tell you something is live when the live product is still showing something else. It isn’t lying. It is simply wrong.

After getting burned a few times, I stopped accepting “done” as proof that something was actually done. I started checking the real result myself.

Eventually I also had to learn how to manage the AI itself. Better prompts weren’t enough. I needed rules about what it could change, what it should leave alone and, most importantly, what I still had to verify myself.

I started this project knowing almost nothing about software development. Two months later, I certainly wouldn’t call myself a software engineer. But I have learned far more about building software than I ever expected to know.

Security changed my mindset

Security was probably the part that worried me most.

If a button looks wrong, I can see it. If a report doesn’t make sense, I can read it. But security is different. A website can look completely normal while something underneath is wrong, and as someone without a technical background, that was uncomfortable.

Very early in the build, security issues made me realise that I couldn’t treat Liberonym as an experiment anymore.

If people were actually going to use it and rely on it, I had to treat it as a real product.

So security became part of the development rather than something to worry about just before launch.

I had the same reality check with external systems and data. Something that sounded like a simple connection could suddenly consume a huge amount of time. AI could move very quickly, but the rest of the world didn’t always cooperate at the same speed.

I learned that repeatedly.

Day eleven

Around day eleven, it all caught up with me.

I was dealing with development problems, security concerns, integrations that wouldn’t cooperate, things I thought were finished becoming broken again, and early users telling me what they didn’t like.

I was exhausted.

That was strange because only a few days earlier the whole experience had felt almost magical. I had spent years thinking this product would be difficult to build, and suddenly I was watching it appear in front of me at incredible speed.

Then I discovered that moving fast doesn’t make the difficult parts disappear. Sometimes it just means you reach them faster.

There were days during these two months when I couldn’t believe how much I had managed to build.

There were other days when I couldn’t believe how much was still going wrong.

Both were real.

The question that changed the product

I started putting Liberonym in front of real people quite early.

One user looked at the report and asked:

“What’s the difference between your report and ChatGPT?”

That hurt a little.

I knew how much work was behind what he was looking at. I knew it wasn’t just a ChatGPT response. But that didn’t matter. If he couldn’t immediately understand the difference, that was my problem, not his.

Other users gave me similar reality checks. They weren’t interested in how many things Liberonym could check. They wanted to know what mattered.

Does something relevant already exist?

Is this similarity actually important?

Does this name work for this business?

What should I be worried about?

They weren’t asking Liberonym to know less. They wanted it to make what mattered easier to see.

That changed how I thought about the product.

Until then, I had probably been measuring progress partly by how much Liberonym could do. More checks, more sources, more intelligence.

But users don’t buy complexity. They want help making a decision.

That is when Liberonym started becoming, in my mind, something more than a name-checking tool. It was becoming a Brand Decision Platform.

By launch, Liberonym was bringing together structured evidence from more than 100 customer-live sources and official search routes across 50 launch markets, together with dedicated intelligence around legal issues, distinctiveness, language, culture, digital identity and other things that can matter before someone commits to a name.

That’s a long way from where I started on August 2.

But the objective became simpler, not more complicated:

Show people what matters.

The name that had to survive its own scrutiny

There is an irony in all of this that I genuinely enjoy.

One of the first names Liberonym ever evaluated was Liberonym.

The early product was much simpler then. It checked the things I had originally thought were important, and Liberonym cleared them.

I liked the meaning. The name was distinctive. The identity around it was available enough for me to build something strong. So I chose it.

Then I continued building Liberonym.

The more research I did, the more I realised how many things the early version wasn’t checking. The product became more demanding and started looking at names from perspectives I hadn’t originally considered.

Eventually, the more sophisticated Liberonym found a problem with its own name.

Liberonym isn’t especially easy to say.

Some people hesitate when they first see it. Some aren’t sure how to pronounce it. And yes, people criticised the name.

I thought seriously about that.

I could have changed it, but I decided not to.

The meaning still works for me. The identity is strong. It is distinctive. And I still believe it is the right name for what I want to build.

That doesn’t mean the weakness isn’t real.

Actually, that became one of the lessons of the whole product for me. A name doesn’t have to be perfect. Finding one weakness doesn’t automatically mean you should abandon it. What matters is knowing what you’re choosing before you commit to it.

And there was one thing I definitely wasn’t going to do: change Liberonym’s standards so that Liberonym itself looked better.

If my own product told me my own name had a weakness, then the weakness stayed.

In fact, it made me want the product to become tougher.

I want Liberonym to help people find great names that survive much more scrutiny than Liberonym itself faced when I chose it.

So in a strange way, Liberonym became one of Liberonym’s first case studies.

The more I worked, the bigger the problem became

When I started, the idea sounded fairly simple:

Check a name before committing to it.

Two months later, I know that sentence hides a huge amount of complexity.

Is the name available? Is there a legal problem? Can people say it? Will they remember it? Does it mean something unexpected somewhere else? Is the digital identity workable? Is it distinctive? Could it be confused with something that already exists?

And those are only some of the questions.

The more I researched, the more horizons opened.

At first, that was frustrating because every new question seemed to create more work.

Now I see it differently.

That is the opportunity.

Liberonym started as a way to check a name. What I want it to become is a way to help people see a proposed name from angles they might never have thought to investigate themselves.

And I know now that we are only at the beginning of what it can do.

Where that leaves things

Two months ago, I had an old idea and no software-development background.

Today, people can actually use it.

I built it without a traditional team, with AI helping me do things I simply could not have done myself two months earlier.

But it wasn’t easy.

I lost days. Things broke. AI fixed one thing and damaged another. Security scared me. Users criticised the product. People criticised the name. Eventually, the product itself criticised the name.

And I’m glad all of that happened.

Because the point of these two months was never to prove that a person with no coding background could build a lot of software with AI.

I wanted to finally build something I had wished existed for years:

a way to understand a name before you build everything around it.

AI gave me the ability to finally do that.

For the first time, the distance between understanding the problem and being able to build something to solve it became small enough for me to cross.

That’s what changed for me.

And now the interesting part isn’t what I managed to build in two months.

It’s what people will do with it next.