Here we will propose a practical framework intended for Citizen Dev for 2025. This set of tools, designs, and methods will evolve over time, but what will remain constant is the desire to simplify things through, among other things, standardization.
In our quest for simplicity, we must standardize technologies, which means there should be only one programming language, and that will be Python. One mode of data quering, SQL. One style of API, REST.
Code
The Citizen Dev produces code, code that operates the information system, observes it, and freely modifies its state. The Citizen Dev is a developer whose job is not to develop.
Once IT has completed its transformation (to which UCD contributes), there will be a tempting risk to impose on the Citizen Dev the same code production rules as those given to the company’s software developers.
The Ecosystem
Simplified view of the architecture:
The Citizen Dev executes two types of code. The first on their local machine, ideally a dedicated Virtual Machine, and the second on a “runtime platform” in the cloud or on-premise, it doesn’t matter.
The first type of code corresponds to very personal and ad hoc use. The second corresponds to processes that need to be scheduled or shared with the rest of the team or reviewed by Athena.
For the runtime platform, we recommend Prefect.
Prefect offers advanced features for scheduling, monitoring, and managing workflows, all in Python.
For any process that does not require a state change, the Citizen Dev will execute their code directly in production. This is possible as long as resource usage limits are applied within the data sources and APIs.
For other actions, those that involve processing and modification, we will do everything to test and execute them directly in production. As much as possible, the Citizen Dev should be kept away from test environments.
We absolutely want to eliminate the software factory, and this is not a teenage whim. In the context of Citizen Dev, it is justified as follows: the nature of the code they produce is less noble than that of software developers, the data they handle is framed by thresholds, the results and processes they operate are local to them or at best affect their team. Finally, as shocking as it may seem, we believe there are conditions to test their code in production.
We also want to eliminate 3-tier architectures and offer the Citizen Dev a direct experience with the data. Historically, this third tier (the server) was built to act as an intermediary between the client and the database. As such, it had to handle security, optimization, business logic consistency, monitoring, and serve as a protective barrier over underlying resources. Most modern storage technologies offer security (row, column), optimization, caching, allocation of dedicated computing units, centralized monitoring. Snowflake and Redshift are excellent examples.
The only aspect not addressed by returning to a 2-tier architecture is the centralization of business logic, but let’s not forget, as already mentioned, that Citizens operate primarily for themselves, and rarely beyond their team’s boundary, so this synchronization is possible through simple governance.
We want to operate only one data source, or rather one representation of that source, which is why we add a data virtualization component. This applies to both APIs and persistence forms that do not support SQL.
The Value of Code : Please Repeat Yourself !!!
The Citizen Dev’s code should be seen as disposable, like pens, razors, and lighters. Based on this observation and driven by our three values, we can deploy our development rules using the MoSCoW method.
Here is a very simplistic example, to be enriched in context:
Must:
- Follow Robert C. Martin’s naming practices
- Any code segment should be rewritable in less than a day.
Should:
- Rewrite the code if more than 30% changes
- Maintain a code complexity threshold below 20.
- Have your code reviewed by an LLM
Could:
- Perform a code review by Athena to improve quality and optimization
- Use performance monitoring tools
Won’t have:
- Class inheritance
- Having code with complexity > 20.
- Coupling code with other teams in the company
If a need arises to create reusable code, or if the code becomes necessarily more complex, then IT will need to be involved.
Python
We confidently claim that Python should be the programming language of choice for Citizen Developers. Its clear and concise syntax, wide range of libraries, versatility, and large community of users make it the ideal option. For all these reasons, Python should definitively replace VBA.
It’s worth noting that even Excel has embraced Python:
Get started with Python in Excel
SQL My Eternal First Love
The days are long gone when an information system consisted of only two databases: one for operational monoliths and another for BI.
In a modern IT, it’s inevitable to encounter different types of databases, each addressing specific challenges.
These include:
NoSQL databases (e.g., MongoDB, Cassandra) for unstructured or semi-structured data.
Relational databases (e.g., MySQL, PostgreSQL, Oracle) for structured data.
Graph databases (e.g., Neo4j) for complex relationships between entities.
Each database type offers a specific way of querying data, such as SQL for relational databases, proprietary query languages for NoSQL, or Cypher for graph databases.
However, Citizen Developers don’t have the time or expertise to master all these query languages and paradigms. Expecting IT teams to standardize all query languages would not only be unrealistic but also counterproductive, as it would reduce efficiency and flexibility in data processing.
So, what’s the solution?
The first solution lies in setting up abstractions or intermediate layers, such as data virtualization, which allow users to interact with different types of databases using SQL without worrying about the technical specifics of each underlying technology.
The second solution requires more effort and involves copying and transforming data sources into compatible databases.
In any case, this must be implemented within the data platform.
To Summarize Everything
As we said in our introduction, Ultimate Citizen Dev is the meeting point of three forces that must align: IT, the company’s management, and the employees.
Here, we provide the list of tasks that each party will need to accomplish.
Role of IT:
Create an adapted infrastructure:
- Develop a self-service data platform accessible to Citizen Developers.
- Set up data virtualization tools (e.g., Denodo) to simplify access to datasets via SQL.
- Provide a centralized catalog to list available data and their owners (domain data product owner).
Ensure governance:
- Guarantee data security (compliance with GDPR, PII, etc.).
- Oversee traceability (consumption, origin, distribution).
- Implement lightweight but functional governance, adapted to the autonomy of Citizen Developers.
Offer tools and APIs:
- Publish well-documented APIs for data access (read-only or CQRS commands).
- Provide low-code/no-code tools integrated into existing workflows (Power Platform, Mendix, etc.).
Facilitate autonomy:
- Remove unnecessary technical barriers (simplify test environments).
- Promote the use of simple architectures (avoid 3-tier architectures to enable direct data access).
Role of Company Management:
Support the transformation:
- Secure strong commitment from management to fund the necessary training and infrastructure.
- Promote a culture of autonomy and collaboration between business teams and IT.
Encourage adoption:
- Invest in continuous training for Citizen Developers on tools and technologies.
- Raise awareness among business teams about the importance of data management and best practices.
Assess competencies:
- Identify business units ready for this transformation.
- Conduct audits or surveys to measure interest and technical skill levels within teams.
Role of Citizen Devs :
Leverage available tools:
- Make use of self-service tools to access and manipulate data (e.g., Excel, Tableau, Power BI).
- Use APIs and catalogs to meet business needs.
Produce simple solutions:
- Develop scripts or applications tailored to their team while following organizational rules.
- Limit the use of complex macros (e.g., in Excel) to avoid creating technological silos.
Collaborate with IT:
- Rely on IT for critical or complex projects.
- Adhere to the security and governance standards set by the organization.
Engage in continuous learning:
- Actively participate in training to improve their understanding of data and tools.
- Become familiar with concepts like datasets, data freshness, and the technical limitations of systems.
