Ultimate Citizen Dev

A forward pass! The right to make one and only one forward pass! It is from this simple rule that American football definitively distinguished itself from rugby. From there, everything had to be reconsidered: wearing a helmet, changing the size of the ball, adding protections, inventing new positions, defining new strategies, and even altering certain rules.

By elevating the citizen developer, positioning them at the heart of the IT system, making this simple adjustment, we believe we can completely reconfigure, for the better, the operation of corporate IT.
IT in its manufacturing is often presented as a power struggle between two ideologies:
One corporate, the other digital. Gregor Hohpe articulates this differentiation throughout his work The Software Architect Elevator. This dichotomy is insoluble, and attempting to resolve it is unrealistic. The underlying issues of these two IT realms differ profoundly. Web giants primarily face challenges unique to them: real scalability, software products, functional simplicity, development of standards. In the other realm, IT professionals are hidden from business managers; they work to automate tasks, implement controls, and ensure business processes in a viscous bureaucratic mire. They inevitably envy, in a Freudian stage, the freedoms of those working at major web players and clumsily try to capture their practices without grasping their inadequacies. IT that produces value cannot be compared in its organization to IT that is merely a cost optimization center, thus a cost center. Once this reality is accepted, it’s time to consider another path.

And this third path exists: it involves continuing to position corporate IT at the service of the business, but with a business predominantly composed of citizen developers.

The Ultimate Citizen Dev (UCD) aims to reconsider corporate IT by placing “Citizen Dev first” as its primary principle.

We are convinced that this transformation has become essential and irreversible. Therefore, we wish to propose a path here—a path guided by a will and supported by three values.

To begin with, this will is an emancipatory one that seeks to break down the barriers of code and technology, deploying them beyond the territory of experts. In our youth, we used to say: “code belongs to everyone.” We had no idea how true that would become.

The three values accompanying this will are simplicity, independence, and self-improvement, all centered around code. They will guide the choices that lead a company to become a realm of citizen developers.

In the following article, the term IT will refer to corporate IT, considered as a department integrated into an industrial or financial organization. The comments and recommendations do not apply to digital IT or startups.

The Business is a Software Developer

The citizen developer is not, as some might think, an apostate cast out from the sect of IT professionals to find refuge in the business open space. Nor is it a data scientist or some kind of undercover developer working masked, fighting for the users against a devouring and malevolent IT.

At its core, the citizen developer describes a business profile—a regular employee with a rather eccentric gift… they can code. They have undergone a favorable mutation that enhances their capabilities. This specimen, so to speak, causes concern.

They unsettle their colleagues who do not share their technological enthusiasm, though they appreciate their outputs. They alarm IT, which associates them with shadow IT (the ultimate measure of IT efficiency) that must be eradicated. Consequently, IT will restrict their access, limit their tools, and delay evolutionary patches for their tools indefinitely.

The citizen developer emerged from IT’s inability to respond quickly or cost-effectively to specific demands. Indeed, Taylorism has transformed IT departments into large vessels, capable of ambitious voyages but too cumbersome and clumsy to navigate short, precise routes efficiently.

The central idea regarding organization is to consider that all business actors are or should be citizen developers.

This is the first major cultural transformation. Code, the ability to develop, becomes a common skill. This doesn’t mean everyone has the same capabilities. We don’t think like Scrum that estimation is identical regardless of who captures it. That’s also why we’ll describe later a capability scale around citizen dev identity.

The central idea regarding organization is to consider that all business actors are, or should become citizen developers. By stating this, we are not transforming the organization; we are enriching the roles that already exist.

Formerly, my father had a secretary. He wrote with a fountain pen and had her transpose everything to the typewriter. Today it’s unthinkable to imagine an executive functioning this way. Indeed, with the emergence of the desktop PC, everyone, to varying degrees, knows how to type. The same goes for code – an entire generation under 30 has been introduced to programming. This popularization began very early in scientific universities, where having a computer science module is customary (Pascal, C, Delphi). But today this has spread beyond, to all curricula – economic, technical, logistic. In many countries, computer science is taught before higher education, just like math, English, or history. Cherry on top, generative AI is an outstanding assistant for building Python code or SQL from human instructions.

These cultural changes are spreading and will continue to spread in companies; it’s becoming increasingly inconceivable to have collaborators without computer knowledge. The new generation’s ability to know SQL, Python, JSON, HTML changes the rules of the game. In a more distant future, the citizen dev role should even disappear, in favor of the business profile where development capabilities are implicit. If all are citizen devs, then there are no more citizen devs.

A Allegory Of Reading

In the Roman Empire, a soldier who could read and write was exempted from the menial tasks of camp life—a rare skill that set him apart from his comrades. Mastery of literacy was essential for ensuring the flow of information and the smooth execution of operations. However, it was not necessary for all soldiers to be literate; a small group of men sufficed to handle the communication needs. This state of affairs persisted long after the fall of the Empire.

By the 15th century, England, like most European countries, had a literacy rate of around 5% (source). Only a narrow elite, composed mainly of clergy and intellectual aristocrats, could read and write. The rest of the population depended on these intermediaries for all written tasks. A learned minority dominated an illiterate majority.

Doesn’t this situation resemble the state of our companies today? In many organizations, developers often make up less than 5% of the workforce. While this is an estimate, one could reasonably assert that, just as a 15th-century Englishman believed his society would remain this way for centuries, many employees today assume that coding will always remain the domain of a small group of specialists. However, everything has changed, and today, the United Kingdom boasts a literacy rate of over 99%. This striking parallel suggests that, similarly, the knowledge of coding could one day become ubiquitous.

But how was this transformation made possible? What triggered such a profound shift? How did two centuries erase more than 300 years of stagnation? The answer lies in two key factors.

The first is technological: the advent of the printing press. The second is political: the idea that an educated and informed nation is a better nation.

For coding, the technological breakthrough has come with the emergence of data as product, APIs, and large language models (LLMs). The political driver is the societal embrace of coding and its integration into higher education and various initiatives (Hour of Code, Code Combat, Code First Girls).

Yet, one thing must not be forgotten. Despite the democratization of literacy, a division remains: between a population that sees reading and writing as an auxiliary skill, and a smaller, minority group that makes a living from it. Think, for example, of journalists, teachers, and writers.

Citizen Devs

As the previous allegory illustrated, there are varying levels of expertise in any field. While a citizen developer will never be as skilled as a professional developer (nor is that their goal!), there are nonetheless different grades among citizen developers that need to be described, as these distinctions contribute to the effective functioning of an organization. By defining a scale, the company can understand what it can expect from them and provide the right training and growth opportunities.

Here, we propose a three-tiered model inspired by the manga Saint Seiya. This framework includes Bronze, Silver, and Gold Knights. Of course, each organization is free to craft its own mythology, but what matters is a clear framework outlining expected skills.

A Bronze Knight must be able to:

• Understand the basics of a procedural language (variables, loops, functions).
• Use AI tools to write code or SQL.
• Work with an IDE (run, debug).
• Have elementary SQL skills.
• Use Git at a basic level (pull, commit, push).

A Silver Knight should:

• Be comfortable writing procedural code for projects under 3,000 lines.
• Have some knowledge of object-oriented programming.
• Understand REST fundamentals (GET, PUT, POST, DELETE).
• Work with and understand JSON/CSV formats.
• Use SQL at an intermediate level (joins, aggregate functions, indexes).
• Navigate Git with intermediate skills (branching, cherry-picking, forking).

A Gold Knight must:

• Be proficient in object-oriented and functional programming.
• Have a strong grasp of security principles (Basic Auth, OAuth2, Encryption).
• Possess foundational infrastructure knowledge (networks, memory/CPU management).

Of course, these skill lists are illustrative and should be expanded to fit the company’s specific challenges and technological context.

In the manga, whether they were Gold, Silver, or Bronze Knights, all served under Athena, their protector. Despite her superior abilities, Athena always prioritized the welfare of her knights over her own interests. Similarly, citizen devs need their own Athena!

Athena comes from the IT department and is there to compensate for the knights’ limitations. She provides support for all things related to coding, databases, deployment, and environment management.

Methodology: Did You Say Agile?

The citizen developer produces code; they create technological value. Like any form of production, this inevitably involves a methodology, whether conscious or not. While agile practices dominate today, does this mean we should directly transfer one of its frameworks (Scrum, Kanban, Extreme Programming, The Heart of Agile) to citizen developers?

We must never forget that citizen developers are first and foremost employees whose primary mission is to focus on their core business responsibilities. The autonomy they gain from their technological skills is not an end in itself. Above all, their tasks should not be made more complicated. In this respect, a framework like Scrum should be avoided entirely, as it comes with a bureaucratic footprint (ceremonies, iterative scoping, goals). Even Kanban is too heavy. 
Let’s illustrate this with a practical example. A salesperson wants to know if the best-selling items over the past three days align with those their customers are purchasing, so they can adjust recommendations and promotions accordingly. Using a Python script they write, they connect to data as product: CRM, Articles, Trades. After validating the queries with Athena, they publish the report in CSV format to an S3 bucket, still using Python, and call the company’s notification API if certain thresholds are met. Following a quick code review, Athena automates the process—a task the salesperson could have done themselves, but they had a meeting to attend.
Voilà, is there really a need for an agile methodology here???

No! Only a few guiding values are required to structure and justify these decisions. These values create a framework, a methodology in its own right, but one that does not fall within the realm of agility.

Simplicity

If something seems simple to use, it’s almost certain that someone else has managed its complexity. Simplicity is a value that Kent Beck carefully emphasized when he founded Extreme Programming. He aimed to ease developers’ fear of overcomplicated, hypothetical abstractions:
“Assume simplicity—Treat every problem as if it can be solved with ridiculous simplicity. The time you save on the 98% of problems for which this is true will give you ridiculous resources to apply to the other 2%.”

In our case, simplicity aims to provide citizen developers with a streamlined experience. This is where the partnership between traditional IT and this new family of coders must find its true meaning:

IT must provide a turnkey development environment. This could include virtual machines pre-configured with tools like VSCode (with necessary plugins installed), Python 3.x, Postman, Git, and DBeaver with primary databases already set up.

IT must offer a set of easy-to-use libraries, particularly for non-functional aspects. This includes areas like security, logging, and performance optimization.

IT must ensure the deployment of a ubiquitous language across all its modeling efforts. The semantics of APIs, data as product, or event-driven systems must be comprehensible to citizen developers. To achieve this, IT must speak their language—namely, the language of the business.

Independance #FreeBritney

Any form of guardianship stems from good intentions. Unfortunately, over time, it can sometimes evolve into an obstacle to fundamental freedoms. This is what happened to Britney Spears, who, after a long battle, finally freed herself from her father’s control. Of course, we remember the end of her story and the struggles she endured to break free, but we must not forget that there was a time when such guardianship made sense.

In short, the business should not have to beg for data or the tools to manipulate it

For years, we infantilized the business side, and it was largely accepted. Why did we so thoroughly confiscate the tools for software production? It was primarily a historical issue that became cultural. The business, aware of its need to see its software ecosystem grow, did not seek to deeply invest in these new technologies. On the IT side, there was a fear of contamination in its operating theater. After all, you don’t let a child fly an Airbus, even if they’re the heir to the airline. So, organizational and technological firewalls were put in place to separate IT from the business.
One of the most striking countermeasures employed by the business was the use of SaaS. Thus, tracking the rise of SaaS tools compared to in-house solutions can be seen as an indicator of mistrust between these two worlds.

In short, the business should not have to beg for data or the tools to manipulate it. Only a vision of IT that provides a self-service offering can ensure the level of independence citizen developers now require. In this setup, a mediator role like “Athena” is crucial.

Self-improvement

Continuous improvement and training are core values for a Citizen Dev. In the past, the best Citizen Devs mastered tools like VBA, Excel macros, SOAP, and Access databases. Today, they must turn their attention to Python, understand data as product, work with REST APIs, leverage cloud data storage, and utilize BI tools.
IT must establish training programs that enable Citizen Devs to embrace these new trends while also fostering their intrinsic growth. This includes supporting a Bronze-level Citizen Dev in advancing to Silver-level status. Additionally, maintaining skills and adjusting training to avoid interfering with the essence of their primary work is essential.
Once again, a role like “Athena” is pivotal—facilitating training sessions, distributing documentation, and organizing skill refreshers.

Conclusion

Web giants are largely made up of citizen developers. Of course, they don’t go by that name; we call them software developers and admire their practices, envy their autonomy, and covet their organization. We seek to imitate them without truly capturing what they fundamentally are.

A developer working on Gmail fully understands what an email, an attachment, or spam is. These are developers who write code to build tools that they then use within their own company. We typically define a citizen developer as a business actor who knows how to code. How would a software developer who practices a trade define it any differently?

One way or another, we are moving toward a new breed of citizen developers. This evolution, driven by the democratization of coding and self-service infrastructure, will require organizational support.

Primarily, this responsibility will fall on the IT department, which must provide these citizen developers with a coherent and straightforward technological ecosystem, a self-service platform, and continuous technological education. Meanwhile, the business side, empowered by this newfound freedom, must learn to recognize its limits and manage the tensions between an eager new generation and a more skeptical one.

Ultimate Citizen Dev is our proposition, a possible version. Within the constraints of this exercise, we have attempted to define a light governance framework, activate a streamlined technological toolkit, and implement a methodology founded on independence, self-improvement, and simplicity.

The citizen developer is a member of a democracy that has long treated them as a minor, but this status is about to change through a more ambitious, stronger, and more ultimate approach.

Here is the visual that perfectly encapsulates UCD.

Now let’s implementing Ultimate Citizen Dev