7 Million Apps in 8 Months: How Emergent Is Building the Platform for Non-Coders

A clinical psychologist in Alaska who coaches equestrian athletes wanted an app that marries sports psychology with horse riding. She couldn’t find one. Dev shops in Nova Scotia quoted her a fortune. So she built it herself on Emergent, and it’s now live on the App Store with hundreds of users. This is the unlock: domain experts who know exactly what to build can finally build it, with nothing lost in translation.

From Testing Agents to World #1 on SWE-bench

Mukund and Madhav Jha are twin brothers who started programming at age 12 in India. Mukund dropped out of his PhD to join Google, then founded Dunzo (a hyperlocal delivery company that became “almost a verb in India,” managing 300 engineers). Madhav built the deep learning team at Amazon.

Their starting insight came from Mukund’s experience running large engineering teams: software testing was the biggest bottleneck in shipping fast. They applied to YC in late 2023 with the idea of automating software testing. VCs thought it was too crazy.

While building testing agents, they discovered a deeper truth: if you can solve verification (knowing whether code works), you can automate all of software engineering. Verification is the loop that keeps agents running for extended periods. This became the foundation of Emergent.

They locked four people in a room and took on the SWE-bench benchmark, then the standard measure for coding agents. In two months, they became world #1. Along the way, they invented multi-agent systems, memory, agent-to-agent communication, and test-time compute scaling. Many of these techniques showed up in academic papers three months later.

“We were like Claude Code before Claude Code was a thing.”

The Pivot Nobody Expected

With the strongest coding agent in the world, the obvious move was enterprise sales. They spent 2-3 months trying. It was too slow.

Meanwhile, they were using Emergent internally to build their own tools. And they noticed Lovable and Bolt were growing like crazy with non-technical users. So they asked: what if we packaged our power tool for people who can’t code?

The beta launched in June 2025. It exploded. Eight months later: 7 million apps built, doubling every 45 days. 80% of users have zero programming knowledge.

The key difference from competitors: Emergent started from the engineering depth and simplified the UX, while Lovable and Bolt started from UX and are trying to add engineering power. This matters architecturally. Emergent built its own Kubernetes infrastructure, its own container stack, its own deployment pipeline. The insight: if you give agents the same infrastructure during build time and deploy time, deployment problems disappear. And owning the infra means faster feedback loops for the agent.

Why Second Movers Win in AI

Every new model generation presents a fresh opportunity to reimagine the product. When Emergent started, GPT-4 was the frontier model, and the industry’s biggest challenge was JSON parsing. They deliberately chose not to solve problems that the next model would handle.

This philosophy extends to their current thinking: Opus 4.5 enables extremely long-horizon tasks and multi-agent coordination. Claude excels at backend debugging; Gemini is strong on frontend. Emergent routes different tasks to different models, extracting 20-30% more performance through their orchestration harness.

The second-mover advantage in AI is real because:

1. You learn from what’s not working for current competition
2. You start from a fundamentally different aperture; your imagination is bigger
3. The real user need becomes clearer: people wanted to ship production software, not just frontend prototypes

The Architecture That Compounds

Emergent’s technical stack is deliberately unconventional: Python backend server + React frontend, a client-server architecture that supports background jobs, async processing, and full-stack applications. Most competitors went with a Node-heavy stack optimized for quick prototyping.

Multi-agent orchestration: The main driving agent handles the primary routine, delegating tasks (testing, design search, API integration) to specialized sub-agents. This keeps context management frugal.

Cross-session memory: The agent learns not just from your current session but across all sessions. Trajectories are aggregated, processed through a CI/CD pipeline, and added to long-term memory as “skills.” If the agent struggled with a calendar integration three weeks ago, it no longer struggles today. This is a form of continual learning that, notably, cannot be replicated by generating skills from the agent itself; they must come from real trajectories.

Agent experience (AX): The team has coined “agent experience” as a metric, analogous to user experience. They measure how the agent “feels” on the platform, what feedback it gets, what constraints it operates under. As models get more capable, the key is giving them more autonomy, loosening the harness. Initially the control was strict; now, more autonomy leads to better performance.

Building for Production, Not Prototypes

The live demo shows several production apps:

• AV Setup business in Illinois: A non-coder built a full-stack lead generation app for audio/video installation, replacing spreadsheets and phone calls
• CRM for lawyers in Norway: A “business developer” (his term) who sold his previous company to PE and built a legal CRM because he knew exactly what lawyers struggle with
• Internal Asana clone: Emergent’s own QA engineer started with “clone Jira” and iterated until they had a custom project management tool that saves $3-4K/month in SaaS subscriptions and fits their three-times-a-day shipping cadence

The design quality is deliberate. Early on, there was a hard trade-off between design and functionality. They invested heavily in solving it: sharing context in a way that produces both good design and working backends.

For non-technical users, they hide the VS Code editor and code diffs entirely. “Even our fairly technical PM gets intimidated by JSON.” The agent asks clarifying questions before building, and users can provide their own API keys or just say “use Emergent’s LLM key.”

A 20-Person Team Doing the Work of Hundreds

Emergent runs with about 12 engineers, mostly in Bangalore. Their hiring philosophy: index on problem-solving ability and ownership. They obsessively recruited top-100 IIT rankers (India’s most competitive engineering exam). Their deployment system, which mirrors Vercel, is built by two people. Their memory system, a problem multiple startups are trying to solve, is built by one.

Everyone in the company does customer support and talks to customers 1-2 times per week. This was a painful decision for a 12-person team (taking one of your best engineers off shipping to handle support tickets), but it built customer empathy from day zero. When they launched, Mukund spent five straight days doing nothing but customer support, much of it in French and German via AI translation.

The team structure itself is evolving: PMs are “vibe coding” internal tools, roles are combining. One person does the work of a PM, designer, and engineer. This mirrors what they see on the platform: the five-person team collapsing into a single builder.

The $500K App for $5K

The core user profile: small-medium business owners running their operations on email, WhatsApp, and spreadsheets. They would have gone to a dev shop for custom software at $500,000. On Emergent, they build it themselves for $5,000.

The value isn’t just cost. It’s fidelity of intent. As the Norwegian lawyer CRM builder explained: “I’m the only builder on my team. I don’t bring in anyone else because I know exactly what to build. Nothing is lost in translation.”

The numbers are staggering: someone has already raised $4 million on a product built entirely on Emergent. 20% of apps being built are agentic, embedding Emergent’s own agent inside user applications to power automated workflows.

Is SaaS Dead?

The Jha brothers see two headwinds for traditional SaaS:

1. Agent consumption: More SaaS workflows will be consumed by agents. Unless SaaS companies pivot to agent-first, survival becomes difficult.
2. Personalized software: People will increasingly build custom tools (like Emergent’s internal Asana replacement) rather than adapt to generic SaaS products.

But the framing of “SaaS is dead” misses the bigger story. This isn’t about destruction; it’s about creation. The conversation reframes AI’s impact away from job replacement toward individual empowerment. People with domain expertise and a business idea, but no coding ability, can now build production software and launch businesses.

Some Thoughts

• The Jevons Paradox of software: As tools get more powerful, people don’t build less; they build more. Software engineering job postings are going up, not down. YC internally is seeing more work, more ideas, more output per week. It’s hedonistic adaptation: “Oh this is more powerful, now I can do more.”

• The niche of niches: In a world of limited software, an app marrying clinical psychology with horse riding would never exist. In a world of unlimited software, it does, and finds hundreds of users. This is PG’s long arc from IBM careers to startup founding to solo builders at the intersection of their unique interests.

• Models will commoditize; understanding customers won’t: Mukund’s view is that foundation models will converge in capability and price, with open source 3-6 months behind. The durable advantage belongs to whoever understands user needs best and builds closest to them. The coding itself is only 20% of the job.

• Verification is the meta-insight: The thread that connects everything, from SWE-bench dominance to production reliability to agent swarms, is verification. Can you automatically confirm the job was done correctly? That’s what enables long-horizon agent work, and it’s where Emergent is investing in custom fine-tuned verification models.