The rise of the citizen developer

When Figma moved design from desktop applications to the browser, something unexpected happened. Designers got faster. But so did product managers creating wireframes. Engineers started leaving design feedback inline. Marketers started building landing pages. The tool didn't just improve a workflow. It expanded participation.

The same shift is happening in software development. When a development environment is pre-configured, runs in a browser, and has an AI agent built in, the barrier to contributing to a codebase drops significantly, and not just for engineers.

• For data scientists building models.
• For analysts turning insights into internal tools.
• For support engineers who can talk to the codebase to get an up-to-date answer for their customers.
• For domain experts who understand the business problem better than anyone and have never opened a terminal.

Forrester's 2025 Developer Survey found that 89% of development executives are either implementing or planning a citizen developer strategy. We see this across our customer base today: pharmaceutical companies giving data scientists self-serve access to pre-configured environments, insurers enabling analysts to turn models into internal applications, finance teams building tools to help them do year close at lightning speed.

The pattern is always the same: domain experts working with Ona Agent, shipping solutions that used to sit in software teams' backlogs for months.

Low-code promised this. Ona delivers it.

Low-code platforms tried to democratize software by building a new abstraction.

Visual builders, flowchart editors, drag-and-drop logic. It worked for simple automations. But the abstraction was still something you had to learn, and in many cases became like learning a programming language in itself. For more serious work such as data science, modeling or statistical analysis, low-code was never a real option as this workflow is not a flow chart.

AI agents sidestep the abstraction entirely. A data scientist describes what they need in natural domain language, and the agent writes code, runs the work, and delivers results.

But the agent is only half the equation. The other half is where that work happens: the environment.

An agent without a well-configured environment is a suggestion engine. It can generate code, but it can't install dependencies, start services, run tests, or verify its own output. The environment is what turns a conversation into working software. A well-configured environment benefits everyone equally: an engineer gets a reproducible workspace, an agent gets a reliable execution context, and a citizen developer gets a working, compliant setup without filing a single setup ticket.

How Ona makes every user productive

Ona is built on three layers: Environments, Agents, and Guardrails. Together, they create a platform where engineers, agents, and non-developers all operate from the same foundation, in a way that means the CIO and CTO can still sleep at night.

Environments are the unlock. Every user gets a pre-configured, sandboxed environment and access to VS Code in the browser. Configure once, and everyone benefits.

No local setup. No dependency conflicts. No "works on my machine." The right language runtimes, packages, services, and connections, all configured in code via Dev Containers and automations, ready before the user types a word. Environments are ephemeral and policy-aware. Admins have full visibility.

This is what makes citizen development possible at all: the environment does the infrastructure work so the user doesn't have to.

Agents carry the expertise. A citizen developer doesn't know your team's branch naming, PR process, or code standards, and they shouldn't need to. AGENTS.md teaches agents your team's conventions. Organization-level skills let admins create workflows anyone can invoke manually and the agent will discover automatically. The agent follows your team's processes on behalf of the user, so a data scientist shipping an internal tool hits the same quality bar as a staff engineer.

Guardrails make it governable. Veto gives you kernel-level controls. Audit logs capture every action by every actor, human or agent. SSO and RBAC mean everyone authenticates within the same governance framework.

Every environment runs in its own isolated VM. For regulated industries — pharma, insurance, banking — this is the difference between wanting to enable self-serve development and actually doing it.

The environment is the equalizer

Companies that standardized their development environments unlocked agents and citizen development early. The same compounding effect applies here: a well-configured environment doesn't just make engineers faster or agents more reliable. It makes everyone who touches the codebase able to contribute safely.

Citizen development is already happening inside your company. The only question is whether it happens on a governed platform, or in the shadows.