Citizen Developers in the AI Era: Business Teams Build, IT Governs
AI gives business teams new power to build apps and workflows. A citizen development program makes that speed safe: clear ownership, risk tiers, reusable controls, and IT oversight built into the platform.

TL;DR: what you'll build. A citizen developer is a business employee, not a software engineer, who builds apps, agents, or workflows to fix a process they own. In the AI era, almost any operator can describe an app in plain language and get something that runs. The risk isn't that business teams build. It's that they build on ungoverned tools, with secrets in code and no owner once the builder moves on. This guide gives you a citizen development program: a role definition, a risk-tier matrix, an intake template, and the exact build pattern IT can approve once and reuse forever.
What is a citizen developer?
A citizen developer is a person who builds a working application, workflow, or AI agent for their own team without being a professional software engineer. They are not part of an engineering org chart. They are a claims adjuster, a recruiter, a plant supervisor, or a revenue operations analyst who understands a process better than anyone in IT does, and who now has tools that let them act on that knowledge directly.
That part hasn't changed since the low-code era. What has changed is the interface. A citizen developer in 2026 doesn't drag boxes onto a canvas. They describe what they want in a sentence, and an AI-assisted builder produces a working app, complete with a database, a form, and in some cases an agent that makes judgment calls on incoming data. The barrier to building dropped again, and it dropped further than low-code ever did.
Citizen developer meaning
The core definition has three parts: the builder is a business-side employee, the problem is one they live with daily, and the output is working software rather than a one-off spreadsheet or macro. A citizen developer meaning that only covers "person who uses a no-code tool" misses the point. The real test is ownership: do they understand the process well enough to make the judgment calls the software needs to encode?
Citizen development vs. professional development
Citizen development is the organizational practice of letting business employees build and maintain software for their own domain, under a program with defined guardrails. Professional software development is the discipline of building and operating complex, shared, or high-risk systems, typically across teams and with formal engineering practices.
The distinction is about role and scope, not skill or status. A citizen developer building a departmental intake form is doing valuable, appropriate work. The same person should not be the one architecting a shared customer database used by five teams, taking payments, or writing code that touches regulated financial records without engineering and security involvement. Complexity and blast radius decide who builds, not whether someone has an engineering title.
This piece is part of Major's broader guide to the governed software factory, which covers the operating model for business teams and agents building production software under one platform. If you lead platform, security, or IT strategy for your company, that pairs with this guide: one covers the factory's architecture, this one covers the people and process layer that makes citizen building safe.
Why AI raises the stakes for citizen development
AI didn't invent citizen development. It removed the two things that used to slow it down: the learning curve of a no-code tool, and the wait for an available developer. Now the backlog of good instincts about process pain moves straight into working software, almost as fast as a business team can type.
That speed is colliding with an IT function that has not scaled to match it. Retool's November 2026 survey of 300 technology leaders, "Governing the Agentic Workplace," found that 89% of IT leaders report at least one AI agent already in production at their company. That adoption curve outpaced governance.
The backlog problem
Every new AI tool a team wants to try becomes an unbudgeted security review. Retool's survey found 54% of leaders say business teams move faster than IT can review their work, and 55% say they lack enough staff to govern agents at scale. The requests don't stop coming just because the review queue is full.
The credential problem
When a business team can't wait for IT, they often solve the access problem themselves. The same survey found 40% of organizations configure data credentials agent by agent rather than centrally, and 20% admitted credentials had been shared insecurely just to make an agent work. That is the shadow IT risk in its most literal form: a password or API key pasted into a prompt, a script, or a shared document because the proper channel was too slow.
The visibility problem
A separate "State of AI Governance" report cited by Retool found only 5% of CIOs, CTOs, and CISOs report full visibility into the AI tools running in their production environment. Most leadership teams cannot name every agent or vibe-coded app currently touching customer data, a database, or an external system.
What this looks like in practice
Put together, this produces a familiar pattern: a business team builds a prototype that works, nobody formally owns it, it has no authentication or observability, and it quietly becomes load-bearing. When it breaks, engineering inherits maintenance for code they didn't design and don't understand. Meanwhile, an AI mandate from leadership stalls because every new idea needs a security review that doesn't have the staff to clear it.
None of this means citizen development should stop. It means the platform business teams build on has to carry governance by default, instead of governance being a step someone has to remember to add.
A citizen development program that scales without making IT the bottleneck
A working program names three roles and gives each one a job, so that no single person is the approval bottleneck for everything.
- Business builder. Owns the process, writes the plain-language spec, and is the first point of contact when the app misbehaves. They do not own platform security decisions.
- Platform owner (IT). Owns the shared environment: identity, connectors, deployment, and the default controls every app inherits. They review requests that cross a risk-tier boundary, not every app.
- Security or risk approver. Signs off only on the requests that touch sensitive data, money, identity systems, or external-facing actions. Most requests never reach this desk.
- Process owner. The accountable manager for the business outcome; names who gets paged if the app's decision is wrong, and signs the recertification each review cycle.
The intake form
Every request starts with a short form, not a meeting. At minimum, capture:
- The problem owner and their manager.
- Who will use the app (and whether any external users are involved).
- The data classification involved (public, internal, confidential, regulated).
- Which connectors or systems it reads from or writes to.
- Whether it performs read-only actions or writes/changes records.
- The impact if the app's decision is wrong (inconvenience vs. financial or compliance exposure).
- Whether a human approves actions before they take effect.
- The named support owner once it ships.
- The success measure the owner will track.
This form is also how you decide the risk tier below, without a meeting for every request.
Use risk tiers to decide what needs review
Not every app needs the same scrutiny. A four-tier model lets most work ship fast while reserving real review time for the requests that deserve it.

Risk-tier approval path, from sandbox to governed production
- Tier 1, sandbox. Synthetic or sample data only, no live connectors. Any business builder can self-serve. No formal review; the platform owner is notified for visibility only.
- Tier 2, internal read-only. Live data, but read-only scopes against approved connectors (for example, reading a CRM to build a dashboard). The platform owner reviews the connector scope once; no per-app security review.
- Tier 3, limited write, internal workflow. The app writes to a system of record within a bounded, named workflow (updating a status field, creating a ticket). Requires a named process owner, a defined human-approval point for anything irreversible, and a platform owner sign-off before go-live.
- Tier 4, sensitive, external, financial, or identity-impacting. Anything touching payments, personally identifiable or regulated data, authentication systems, or external-facing actions. Requires security/risk approver sign-off, mandatory human approval before any write, and a recertification date, typically every 90 to 180 days.
Each tier also needs a retirement rule. An app with no owner left at the company, or one that hasn't been used in its recertification window, gets flagged for deactivation rather than left running quietly in the background. This is the same discipline the NIST Secure Software Development Framework calls "Protect the Software" and "Respond to Vulnerabilities": the controls apply across the software's life, not only at launch.
Architecture: app, agent, workflow

The governed software factory for citizen development: app, agent, and workflow split
The way to make this safe without slowing anyone down is to split the build into three distinct pieces, each with its own job.
The workflow is the deterministic backbone: the trigger (a schedule, an event, or a form submission), the ordered steps, and the required approval gate. It runs the same way every time, which is what makes it auditable.
The agent handles only the judgment calls: classifying an ambiguous request, drafting a recommendation, or flagging something as an exception. It never has standing write access to a system of record on its own; it hands a recommendation to the workflow, which enforces the approval step.
The app is the human interface and the system of state: the review queue, the status table, the history of every request and decision. It's built once on Major with a managed database, SSO, and audit logging already wired in, so the business builder isn't choosing those controls, they come with the platform.
Think of it like a loan application. The loan officer (the agent) reviews the file and recommends approve or decline. The bank's processing system (the workflow) enforces that no loan disburses without a countersignature. The branch's paper trail (the app) is what an auditor pulls eighteen months later to see exactly who decided what and why.
What this looks like on Major
Major is the enterprise platform where business builders and agents build the software they run on, with identity, permissions, audit, database, and storage handled by the platform rather than assembled by each builder. Here is the concrete build sequence for a citizen-built process, using an HR onboarding handoff as the running example.
- IT connects each system once. A platform admin links Greenhouse and Workday through Major's connector setup, with credentials stored in Major's central credential store rather than in a prompt or a config file. You should see the connector listed once, with scopes visible to IT, and reusable by any app or agent the business team builds afterward.
- IT provisions the workspace and roles. The platform owner turns on SSO for the team and assigns roles: submitter, reviewer, and admin. You should see each business builder land in the workspace already authenticated, with no separate password to manage.
- The business builder describes the app in plain language. The HR operations owner gives Major a prompt describing the problem and the fields involved.
"Build an HR onboarding handoff app that tracks approved Greenhouse offers, validates required fields, and prepares a Workday worker record for HR review. Store status and change history, and require approval before any write."
- Major builds the app with its managed tables. You should see a request table (one row per offer, with status, assigned reviewer, and a full change history) and a review queue screen where a reviewer can approve or reject a prepared record.
- The builder adds the agent that makes the judgment call.
"When a new approved offer comes in, check for missing or inconsistent fields against the Workday worker schema, and prepare a recommended worker record. Flag anything with missing compensation or start-date data as an exception instead of auto-approving."
You should see the agent populate a draft record and attach its reasoning as a note on the request, not write anything directly.
- Set the workflow trigger. The workflow listens for a Greenhouse offer-accepted event (or polls on a schedule if no event subscription is configured) and starts the pipeline: pull the offer, run the agent's check, route to the review queue. You should see a new row appear in the app automatically, with no one having to kick off the process by hand.
- Test in a sandbox tier first. Run the workflow against a handful of synthetic or already-processed offers before connecting it to live Workday writes. You should see the review queue populate correctly and the agent's recommendations match what a human would have proposed.
- Roll out with permissions and the approval gate live. Promote the connector scope from read-only to the limited write needed for Workday worker creation, require the HR reviewer role to approve every record before it writes, and turn on audit logging for the write action. You should see every write in the app's history tied to a logged approver and timestamp, with the underlying credential never exposed to the builder or the agent.
Once this pattern exists, the same shape applies anywhere a business team spots a repeatable, judgment-involving process: a marketing operator reconciling GA4 anomalies into HubSpot campaign briefs, a finance analyst escalating Brex spend exceptions into NetSuite, an ops lead routing Shopify fraud-risk holds to Gorgias, or a sales operations owner running Apollo.io lead enrichment into Salesforce. Each is a bounded workflow a business owner specified, built on the same governed platform, with the same approval discipline.
Governance and IT control
None of the speed above is worth much if IT can't see or stop what gets built. The controls that matter for citizen-built software are the same ones that matter for any production system, applied consistently instead of ad hoc.
- SSO and role-based access mean a business builder authenticates through the company identity provider, and their role (submitter, reviewer, admin) determines what they can approve, not just what they can see.
- Scoped credentials through a central credential store mean the Greenhouse or Workday connector is set up once by IT, with the minimum scopes the workflow needs, and no builder or agent ever sees the underlying secret.
- Audit logs record who submitted a request, what the agent recommended, who approved it, and when the write happened, so a security review eighteen months later has a complete trail rather than a builder's memory.
- Managed database and storage mean the app's state lives in Major's platform rather than in a spreadsheet on someone's laptop or a personal cloud drive.
- Versioned deploys mean a change to the app or agent's instructions is tracked and can be rolled back, the same discipline NIST's SSDF expects from "Produce Well-Secured Software."
- Approval requirements are attached to the risk tier, not to the builder's seniority: a Tier 4 action always needs a named approver, regardless of who built the app.
The NIST AI Risk Management Framework frames this as four continuous functions: govern, map, measure, and manage risk across an AI system's life, not just at launch. For a citizen-built HR or finance workflow, that means naming the process owner (govern), classifying the data and action risk (map), tracking exceptions and approval rates (measure), and recertifying or retiring the app on a schedule (manage).
Failure handling and edge cases
A citizen-built workflow will eventually hit something it wasn't designed for, and the program needs a default answer for when that happens rather than leaving it to the agent to decide.
API errors and rate limits should trigger a retry with backoff, not a silent drop. If Workday's API returns a rate-limit error, the workflow should wait and retry, then flag the request as stalled if it fails repeatedly, rather than losing the record.
Partial syncs and duplicate events need idempotent handling. If Greenhouse sends the same offer-accepted event twice, the workflow should recognize the existing request by its offer ID and update it, not create a second worker record. An idempotent sync is like a doorbell with a memory: pressing it twice doesn't summon two deliveries, because the system remembers it already answered.
Stale data is a silent failure mode. If the agent is working from a cached read of the Workday schema that's since changed, it should fail safe (flag for human review) rather than write against assumptions that no longer hold.
The agent should never be allowed to approve its own recommendation, bypass the write-scope the connector was configured with, or escalate its own permissions. Those are structural boundaries enforced by the workflow and the credential scope, not instructions the agent is trusted to follow on its own.
When any of the above happens and the workflow can't resolve it automatically, the fallback is always a person: the request sits in the review queue flagged as an exception, with the agent's reasoning attached, until the named reviewer looks at it.
A worked example with numbers
For example, consider a 200-person company whose HR team currently handles roughly 15 new-hire offers a month by hand: copying offer details from Greenhouse into Workday, checking for missing compensation or start-date fields, and routing anything unusual to a manager for a judgment call. Each handoff takes an HR coordinator about 25 minutes when everything is clean, and up to 45 minutes when a field is missing and needs a follow-up email.
With the workflow above in place, the agent classifies each incoming offer within roughly a minute of the Greenhouse event firing: most fields match cleanly and it prepares the Workday worker record automatically. Say 11 of the 15 monthly offers come through clean. The HR reviewer's job on those is a two-minute approval click in the review queue, rather than a full manual entry.
The remaining 4 offers a month have a missing or inconsistent field (say, a late start date or a compensation band mismatch). The agent flags these as exceptions with its reasoning attached, rather than guessing, and the HR coordinator spends roughly the same 45 minutes resolving them as before.
Illustratively, that's 11 x 2 minutes plus 4 x 45 minutes, about 202 minutes a month of HR time, down from roughly 15 x 30 minutes (a blended average) or 450 minutes today. The time saved doesn't eliminate HR's role in the process. It moves their attention from retyping clean records to the handful that actually need a human decision, which is the judgment the role is for in the first place.
What to measure
Track a small number of metrics the process owner already cares about, rather than inventing new ones for the sake of the program. The point of measuring is to prove the workflow is actually reducing manual work, not just that it exists.
- Cycle time, from the triggering event (offer accepted) to the system-of-record write completing.
- Exception rate, the share of requests the agent flags for human review instead of auto-preparing.
- Manual touches per request, to confirm the work is actually moving off the coordinator's plate.
- Approval turnaround, how long a request sits in the review queue before a reviewer acts.
- Recertification compliance, the share of Tier 3 and Tier 4 apps reviewed on schedule rather than overdue.
Review these monthly with the process owner, not just at launch. A rising exception rate usually means the upstream data changed (a new Greenhouse field, a Workday schema update) and the agent's checks need an update, not that the whole workflow has failed.
Frequently asked questions
What is a citizen developer?
A citizen developer is a non-IT business employee who builds apps, workflows, or AI agents using approved tools to solve a problem in their own domain. They work inside a program with platform guardrails, not as an unsupervised individual contributor to production systems.
What is citizen development?
Citizen development is the organizational practice that enables and governs that building: a shared platform, risk-tiered review standards, named ownership, and a lifecycle for retiring or recertifying what gets built. It is the program, not the individual act of building.
What does citizen developer mean in the AI era?
The definition still centers on a business owner building for their own process, but the building now includes natural-language app and agent creation. AI-generated software still needs the same accountability: a named owner, defined data access, and review proportional to risk. The model writing the code doesn't transfer responsibility away from IT or the business owner.
How is a citizen developer different from a professional developer?
A citizen developer builds and maintains software scoped to their own team's process. A professional developer typically works across teams on shared, complex, or high-risk systems, with formal engineering practices like code review and testing pipelines. The difference is role and scope, not ability: complex shared infrastructure still needs professional engineering regardless of how easy app creation has become.
How can IT govern citizen development without slowing teams down?
Use risk tiers so only the sensitive or high-impact requests need a security review. Centralize identity, credentials, and connectors so builders reuse approved access instead of each solving it themselves. Require human approval at the point of risk, not at every step, and keep an audit log so oversight is a query, not a meeting.
Before you go live
Run through this checklist with the business builder and the platform owner together before any citizen-built app or agent touches live data. It takes most teams less than thirty minutes, and it's the difference between a governed app and a prototype nobody remembers approving.
- [ ] Every app has a named business owner and a named platform owner.
- [ ] The risk tier is assigned and documented before the app touches live data.
- [ ] Connectors are set up once, with credentials in the central credential store, never in a prompt or script.
- [ ] SSO and role-based access are enforced for submitter, reviewer, and admin roles.
- [ ] A human approval gate exists before any Tier 3 or Tier 4 write action.
- [ ] The workflow has been tested against synthetic or historical data before going live.
- [ ] Audit logging is on for every read and write the app or agent performs.
- [ ] A recertification date is set, and a retirement path exists for apps with no active owner.
More use cases by tool: More Greenhouse use cases, More Workday use cases.
Start building on Major
Give business teams a governed place to build apps, agents and workflows, while IT manages identity, credentials, permissions and audit.
Related articles
- What Is a Software Factory? The Governed Version for Business Teams
- No-Code AI Agent Builder: What It Is and What to Evaluate
- AI-Powered No-Code App Builder: From Prompt to Governed App
About the author
Ritvij Gautam is Head of Growth at Major.
Last reviewed November 20, 2026 by Ritvij Gautam.
Frequently asked questions
- What is a citizen developer?
- A citizen developer is a non-IT business employee who builds apps, workflows, or AI agents using approved tools to solve a problem in their own domain. They work inside a program with platform guardrails, not as an unsupervised individual contributor to production systems.
- What is citizen development?
- Citizen development is the organizational practice that enables and governs that building: a shared platform, risk-tiered review standards, named ownership, and a lifecycle for retiring or recertifying what gets built. It is the program, not the individual act of building.
- What does citizen developer mean in the AI era?
- The definition still centers on a business owner building for their own process, but the building now includes natural-language app and agent creation. AI-generated software still needs the same accountability: a named owner, defined data access, and review proportional to risk. The model writing the code doesn't transfer responsibility away from IT or the business owner.
- How is a citizen developer different from a professional developer?
- A citizen developer builds and maintains software scoped to their own team's process. A professional developer typically works across teams on shared, complex, or high-risk systems, with formal engineering practices like code review and testing pipelines. The difference is role and scope, not ability: complex shared infrastructure still needs professional engineering regardless of how easy app creation has become.
- How can IT govern citizen development without slowing teams down?
- Use risk tiers so only the sensitive or high-impact requests need a security review. Centralize identity, credentials, and connectors so builders reuse approved access instead of each solving it themselves. Require human approval at the point of risk, not at every step, and keep an audit log so oversight is a query, not a meeting.