“The biggest strength of Neon is how it decouples storage and compute and makes them independently scalable. When an app isn’t being used, the compute node can be put in idle mode at extremely low cost, which lets us handle a wide range of scale and complexity without compromise.”

(Nilesh Trivedi, co-founder and CTO at QwikBuild)

QwikBuild is an AI web app builder with something unique: it first launched on WhatsApp. It allows users to describe the website or app they want directly from there, and receive a live version in minutes.

That simplicity drove adoption right away: since it first launched, more than 15,000 creators have already used QwikBuild to build websites and apps for their businesses. Check out some examples of generated sites here.

The stack behind QwikBuild

QwikBuild’s infrastructure is built to support the autonomous generation, deployment, and iteration of real web apps at scale: 

• The system is implemented in Python (the team built their coordination layer from scratch)
• The AI-generated applications are written in TypeScript
• Neon is used to provision one isolated Postgres DB for each app 
• Drizzle ORM connects generated applications to their Neon database
• Hono is the web framework
• Deno is also used in parts of the runtime environment
• Twilio powers the WhatsApp-based interface
• And all the other cloud infra components run in AWS

Giving every app its own isolated Postgres database (aka, its own Neon project)

Every generated app by QwikBuild is a real web application that needs persistent storage, independent scaling, isolation from other apps, and low idle cost to make the growth rate sustainable.

The QwikBuild team knew that building on top of shared databases would introduce operational complexity as the number of generated apps increased, so they chose a simpler model: every generated app gets its own isolated Postgres instance.

In Neon, this means

• one Neon project per app,
• provisioned programmatically, 
• available instantly,
• and fully isolated by default

If you’re not familiar with Neon, this design might sound expensive and operationally heavy. In any other managed Postgres, deploying independent instances per app can quickly become difficult to manage – but Neon’s unique architecture makes this pattern practical.

Because compute and storage are decoupled in Neon, each Postgres project scales independently, with each compute scaling down to zero when not in use. Implementation is also simple – Neon’s JavaScript packages integrated cleanly with QwikBuild’s serverless environments, coding sandboxes, and function-as-a-service cloud infrastructure.

Scaling the fleet without fearing high costs

“Soon, AI agents will do most of the coding, and perhaps 1000x more database instances will be needed. Neon’s platform and pricing strategy feel aligned with that future”

(Nilesh Trivedi, co-founder and CTO at QwikBuild)

When you’re generating apps programmatically,

• some apps may receive steady traffic,
• others may grow quickly and unexpectedly,
• and many may sit idle for long periods

This variability makes infrastructure planning difficult if compute and storage are tightly coupled. But when deploying a project-per-app model in Neon, 

• Every app (tenant) has storage and compute resources that behave independently of all the other tenants
• Storage scales automatically, without needing to be pre-provisioned in advance, and persists independently of compute
• Compute capacity autoscales when traffic increases (e.g. for apps seeing traffic spikes)
• And when an app goes idle, compute scales down all the way to zero (e.g. for the majority of the fleet that may stay idle most of the time)

This flexibility allows platforms like QwikBuild to support both small business websites and more complex web applications without changing the underlying model. It keeps infrastructure costs aligned with real activity, not with pre-provisioned capacity.

Safe iteration with branching and point-in-time restore

“For autonomous coding, it becomes critical to provide multiple environments for features under development. Neon’s branching and point-in-time restore capabilities are incredibly useful for that”

(Nilesh Trivedi, co-founder and CTO at QwikBuild)

Each generated application evolves over time: features are added, schemas change, and so on. In Neon, 

• Branching allows a database to be copied instantly (including schema and data) without duplicating the full storage footprint. 
• This is perfect for backing independent environments for development or experimentation, which now can be created reflecting exactly the app’s current state without impacting it in any way or adding high costs. 
• On top of this, Neon branches also power instant point-in-time restores, which allows users to recover to a previous state if a migration fails or bad changes are introduced.

Just shipped: AgentQ 

Inspired by the success of QwikBuild’s WhatsApp interface, the team has now launched AgentQ in public beta – their fully autonomous multi-agent system designed for larger enterprises that want the same speed as QwikBuild, but with a different interface and ready for more complex architectures.

AgentQ works on the same primitives as QwikBuild, but instead of relying on a single AI model to generate code in one pass, it coordinates multiple specialized subagents: 

• A Product Manager agent to interpret requirements
• A Project Manager agent to orchestrate execution
• A Backend Developer agent
• A Frontend Developer agent
• A Code Auditor agent to review and validate the output

These subagents are able to work for longer stretches of time to build production-grade apps that are fully deployed on the web. Keep an eye on their beta!