The bottleneck is obvious – IT can’t deliver fast enough, so teams turn to whatever tools they can get their hands on. The prize is speed, some autonomy, and fixes that feel relevant to the people doing the work. Ungoverned this is called shadow IT, but with the correct controls and support in place it becomes citizen development. 

This means that the real challenge for CIOs isn’t whether citizen development should exist, but how to close the gap between its promise and its messy reality. 

A checklist for citizen development  

If you’re considering a citizen development project, you can use this checklist as a guide to help with your decision-making: 

• Is it accessible? Are tools simple enough for non-specialists? 

• Is it ownable? Can teams take responsibility for what they create? 

• Is it safe? Will mistakes be tolerable, maybe even reversible? 

• Is it valuable?  Is the payoff big enough to make people bother? 

This checklist is flexible enough to be applied to any technology or project. We’ll be using low-code and Power Platform as the case study in the rest of the article.  

Low-code and Power Platform: In theory 

Low-code and Power Platform seem to align perfectly with our citizen development checklist: 

• Is it accessible? Yes. Low-code platforms promise drag‑and‑drop simplicity. Business users can point to templates and pre‑built connectors as proof that coding isn’t needed.  

• Is it ownable? Yes. Teams imagine they can control their own backlog- building a workflow today, tweaking it tomorrow, without waiting for IT or dev. 

• Is it safe? Yes. If a simple app breaks, the damage looks limited: a few forms lost, a process delayed, but nothing catastrophic. 

• Is it valuable? Yes. The IT backlog is large. Skip the six‑month wait for IT and you’ve unlocked huge value fast. 

In theory, this evidence makes citizen development an obvious choice for low-code and Power Platform projects. But, in practice, does it line up so neatly?  

Citizen development in practice  

Accessibility is a mirage.  

Low-code hides… code, but there are other barriers. Delivery still has to follow the software development lifecycle (SDLC), which means makers need at least some grasp of analysis, security, testing, deployment, and documentation. Power Platform doesn’t remove those needs, so the idea of an easy entry point is only partly real. 

Ownership is fragile.  

Business users rarely have the time or mandate to keep solutions alive alongside their day jobs. Without some SDLC knowledge (testing, deployment, change control) it’s hard for a team to genuinely own what they’ve built. In many cases, ownership is more theory than reality. 

Safety is a sliding scale.  

IT projects vary widely in risk. A rota for one department is relatively low‑stakes, while anything involving patient data or other sensitive PII is high‑risk. Guardrails are essential to mark where citizen development is acceptable and where IT or professional developers must step in. 

The value is real.  

This one still holds true – the IT backlog is severe, with teams often waiting months for even basic solutions. Breaking that bottleneck can mean delivering something tomorrow instead of next year. 

This is the gap between theory and practice. We can easily see why in theory citizen development is appealing. But in practice the implementation is harder, and uptake is lower than many organisations expect because of this reality. 

How can we close the gap between theory and practice? 

The same checklist can help with mitigations before you start your citizen development project: 

• Make it accessible – Keep entry simple, but don’t confuse easy tools with easy delivery. Offer short, plain training on the basics of planning, testing, and launching a solution safely before giving people building rights. 

• Make it ownable – Ownership needs more than diary time. It rests on executive sponsorship, so work isn’t a side project. Citizen developers need clear processes for support and escalation, and a community or mentoring setup to stop work drifting back to IT. Teams also need allocated hours, role recognition, and IT backup when required. 

• Make it safe – Set clear zones for low‑ vs high‑risk work. Lock advanced features until people are ready. Track builds with dashboards, use safe templates to guide makers, and bring in IT when apps touch sensitive data or need complex design. 

• Make it valuable – Allow for by-passing the IT backlog where the teams are certain the tooling is accessible, they really can own the solution, and they are not taking too much risk. 

Creating a culture for citizen development 

With the right mitigations, CIOs can build an approach that is both safe and more likely to achieve meaningful uptake across the business. However, the most important decision to make is – are we actively pushing citizen development, or merely putting safety and support in place? If it’s the former, then the biggest hurdle we’ve seen at Marra is uptake. Without making it part of a person’s/team’s role, the adoption will likely be low and limited to a handful of curious individuals across your organisation. 

At Marra these principles are reflected in our Centre of Excellence model. It balances governance and innovation by setting clear guardrails on what citizen developers can do, while still giving them the support and space to deliver real value. If you’d like to explore how this works in practice, get in touch for a conversation. 

Written by Ryan Grey, Chief Technology Officer