From a $500M startup to square one

Over ten years ago, I co-founded CodeSignal and helped scale it, as CTO, to a $500M valuation. My friend Eduard was there for the whole climb too. He joined as a founding engineer and eventually became our director of engineering, and we spent years together building software, breaking it, and fixing it, learning the things you only learn when real customers depend on you.

A year ago, we left to start over. Now we're co-founders at Modelence, joined by our former teammate as our founding engineer - three people who have worked together for more than a decade. We're a YC startup in the early days, so we have a very long way to go. I've been trying to explain why we made that decision without turning it into a pitch, and the honest version is that we spent a decade seeing the same unglamorous software problems everywhere, and then AI suddenly made those problems matter to a much larger group of people.

Starting over

It is strange to go from something that looked successful from the outside back to the beginning. At CodeSignal there were teams, customers, and momentum - a machine we had spent years building. Now it is the three of us again, trying to figure out what people actually want, watching signups, reading user messages, and fixing bugs ourselves. Every small number feels very personal.

The obvious question is why leave the first thing to build the second. The answer is that after ten years of building and running software, we could not stop seeing the same problem everywhere.

The problem we kept seeing

Every app we worked on needed the same boring layer underneath it: auth, a database, background jobs. Every time, you either rebuilt that layer yourself or stitched together managed services and hoped the seams held. In the beginning that all feels like setup, but after enough years in production it starts to feel like the whole job. A demo can be impressive and still be nowhere close to a product, because real software has to keep working under load, over time, for users who do not care how elegant your stack is - they just know something broke when they needed it. Most of what I am proud of from those years was invisible: the database not falling over, the background job retrying instead of silently losing someone's work. That was the scar tissue we carried into Modelence.

At first we thought we were building for people like us: developers who already understood the problem and were tired of rebuilding the same production plumbing. Of course we thought that - we are engineers, and we were solving our own pain. Then the market shifted underneath that assumption.

Then, AI changed who had the problem

AI app builders made the demo dramatically easier. Suddenly people could describe an app and watch a working version appear, which is still magical to me. But the more we watched people use these tools, the more familiar the failure mode looked. The demo had gotten easier while the production problem had not. The auth still had to be safe, the data still had to survive real use, and jobs still had to retry. The app still had to become something a person could actually depend on. What changed was who was running into that wall: no longer only engineers, but everyone AI had just invited into software.

That realization changed how we thought about the company. We had built Modelence around a full-stack framework because we believed the foundation mattered, but the more important realization was that the people who needed this most were often not developers. We started seeing non-technical users show up with real ideas: a domain expert building compliance software, a community organizer building a booking system. These were people who understood a problem deeply and could now generate an app, but had no way to make it survive contact with real users, and this is when the company became more interesting to me. The thing we had built to save developers a few hours was, for these users, potentially the difference between a demo and a real product.

What we got wrong

Then we made a very founder-like mistake: we were so focused on what we knew was hard that we underinvested in what users experienced first. Our foundation was solid. Auth worked, the database was wired in, the platform did the serious invisible things we cared about, but the apps looked mediocre. We had treated UI polish as the easy part, because a decade of production had taught us that the hard part was the infrastructure underneath. But for someone building their first app, the UI is the product. They cannot inspect your retry logic or judge your auth model. They look at the screen, and if it feels rough they assume the product is rough. Reliability is something they might discover over weeks, but ugliness they discover in ten seconds.

It was painful because it was obvious in retrospect. We were right that the invisible layer matters, and wrong about how much trust the visible layer has to earn before anyone gives the invisible layer a chance to matter. We have made UI generation much better since then, but it cost us users we should have kept. That has probably been the biggest lesson of the last year: being right about what is hard is not the same as being right about what comes first.

Where we are now

So that is where we are now: three people starting over after a decade together, with thousands of signups and usage growing quickly off a small base. There is something here, but it is not figured out. We left something that looked much more certain to build something that feels much more alive. Some days that feels exciting and some days it feels irrational, but most days it just feels like being a founder again.

What we believe, more strongly now than when we started, is that AI has made it much easier to create software but not yet much easier to own and operate it. That is the gap we are closing.