CitizenssApp: A Platform for Digital Rights and Empowerment Through Table-First Software Design
Zenodo: https://doi.org/10.5281/zenodo.16259916
Introduction: Table–Column–Row (TCR) as a Digital Right
CitizenssApp is a platform built entirely on the Table–Column–Row (TCR) model – the same intuitive format found in everything from paper ledgers to spreadsheets. The idea is simple but powerful: if a person can draw a table with rows and columns, they should be able to create and use software. In the analog world, every citizen could record information with pen and paper; in the digital world, that same simplicity should exist[1]. CitizenssApp treats basic data operations (CRUD – Create, Read, Update, Delete) as a fundamental digital right rather than a complex programming task. “Digital empowerment is no longer a privilege—it is a fundamental need for every citizen. CRUD is the new pen and paper.”[2] The platform’s vision is to democratize software creation by removing cost, complexity, and dependency, much like how universal literacy made reading/writing accessible to all[3][4]. Lack of access to simple app functionality today creates digital exclusion[5], so CitizenssApp frames basic software literacy as a necessity, empowering individuals and communities to build their own solutions.
Under the hood, everything in CitizenssApp – data models, user interface, logic, and workflows – is represented in structured tables. There is no hidden code or proprietary file format; the entire system is declarative, inspectable, and editable – just like a spreadsheet[6]. By using the universally understood tabular format, CitizenssApp ensures a zero abstraction barrier between users and their software: what you see (in the tables) is what the application does, with no opaque layers[7][8]. This design aligns with how real users think and work. In fact, most users already understand that tables = interfaces, columns = fields, and rows = records in everyday tools[9]. By speaking the native language of tables (the lingua franca of programs like Excel), CitizenssApp leverages familiar concepts so that anyone who understands spreadsheets can build software[10]. Academic research underscores the wisdom of this approach: spreadsheets have long been “the tool of choice for ad-hoc tabular data management… especially by non-programmers” due to their direct manipulation and intuitive UI. There are an estimated 750 million to 1.2 billion Excel users worldwide, with Google’s G Suite (including Sheets) reaching ~2 billion monthly users. This ubiquity confirms that tabular data representation is universally understood, making it an ideal foundation for a citizen-centric platform. CitizenssApp elevates the humble TCR model from a data format to a vehicle of digital autonomy – giving individuals agency over their data and applications. In essence, it treats software creation and data control as a Minimum Digital Right (MDR) for everyone, analogous to how open-source and self-sovereign data movements emphasize user control.
Vision Overview:
CitizenssApp’s design is guided by an ambitious multi-point vision that can be grouped into several core themes. Together, these features enable full-stack application creation within the TCR paradigm, from data definition to UI to sharing. Below we discuss these pillars of the platform’s vision:
Full SQL Support – DDL, DML, DQL, DCL, TCL: In CitizenssApp, users interact primarily through a visual table interface, based on the universal TCR (Table–Column–Row) structure. This is the only UI users need — not forms, not code — and it resembles an Excel-like experience where both data and structure evolve together. There is a metadata editor available for power users, but it is never mandatory. The preferred interface is the data-first, Excel-like table that lets users start entering data immediately and evolve structure naturally. This flexibility allows any user to move between structure and content seamlessly—just like they would in a spreadsheet—but with the power of metadata and modular app design behind the scenes. CitizenssApp supports full SQL capability (DDL, DML, DQL, DCL, TCL), but not for traditional database operations. Instead, these command families operate over metadata to define structure, logic, and behavior. DDL-Creates or modifies metadata definitions, do not create physical tables, DML-Captures row edits through the UI and updates stored records, DQL-Enables dynamic filters, lookups, joins, unions on metadata-defined tables, DCL-Controls who can view, edit, or share TCRs, and TCL-Supports undo/redo, checkpoints, and safe changes. All data and metadata are saved to the user’s preferred storage — flat files, JSON, SQLite, cloud sync — without enforcing a relational database backend.
User-first design: Like Excel, users can begin with rows and columns, then shape structure as needed.
Metadata lives behind the table: Users don’t have to think about schema—but it’s always there and editable.
Advanced logic possible: Lookups, joins, prompts, and AI-generated enhancements operate cleanly on metadata.
No database lock-in: Everything works without requiring SQL Server, PostgreSQL, etc.
Role-based control: Organizations can govern what each user can see, edit, or connect via permissions.
In CitizenssApp, the table is the app. SQL is the logic. Metadata is the contract.
Table-First UI with Templates, Charts, and Formulas: Every aspect of application functionality in CitizenssApp is represented and managed through tables and their associated metadata. This table-first philosophy applies not just to data, but also to configuration, presentation, and logic. Even business rules and interface definitions are captured as rows within metadata tables — much like how a spreadsheet defines a layout through cell properties. There is no separate visual GUI builder. Instead, everything that might traditionally be called a “UI” is represented as a set of editable tables. The platform simply renders these metadata tables as interactive views. This approach is a practical example of a metadata-driven table experience, offering adaptability, scalability, and maintainability — without the rigidity or overhead of hand-coded interfaces.
As one industry guide puts it:
“When UIs are in constant flux and hardcoding becomes impractical, metadata-driven approaches step in. They leverage metadata to enhance adaptability and flexibility.”
In CitizenssApp, what might otherwise be described as forms or screens are instead just structured tables.
Users — or the AI — can adjust these tables directly or via prompts, and the app behavior updates accordingly. Formatting (e.g. colors, layouts) and formulas (e.g. calculated fields or validations) are also handled tabularly. This mirrors the Excel paradigm, where styling and formulas live visibly in cells — not hidden in code. Because formulas and logic are stored as structured metadata, they remain transparent, editable, and free of “black box” behavior. Users add or modify rows to build visualizations — just as they would in Excel or Google Sheets. By combining template-driven table definitions, spreadsheet-like logic, and declarative visualizations, CitizenssApp delivers much of the analytical power of modern spreadsheets — but in a governed, modular, and multi-table environment. Unlike monolithic spreadsheets that slow down with large data volumes or complex cross-referencing, CitizenssApp supports multi-table schemas, relational joins, and scalable metadata execution — leveraging its structured architecture to handle millions of records efficiently. The result is a platform that feels as familiar as Excel — but far more powerful, scalable, and shareable. Anyone who understands a spreadsheet can build and evolve apps using tables.
- Storage Independence and Integration Principles: One of the foundational design principles of CitizenssApp is that storage should never be a barrier to user adoption, flexibility, or empowerment. The system is intentionally designed to decouple data storage from data interaction, allowing users to define, manage, and evolve their applications without needing to understand or configure backend infrastructure.
Key Principles
Storage Should Not Be a Barrier
Users must be free to focus on what they want to capture — not how it’s stored. Storage is treated as a backend detail, not a constraint on creativity or access.
Storage-Agnostic Architecture
CitizenssApp operates with complete independence from storage type. Users can store data and metadata in any format, including:
Flat files (e.g. .json, .csv)
Binary formats
Relational databases (e.g. SQLite, PostgreSQL)
NoSQL databases
Excel files
Universal Data Import
Any compatible data source can be imported and rendered as a table, regardless of origin. Once imported, the data becomes part of the TCR environment — accessible through prompts, queries, and templates.
Flexible Data Export
Users can export data in multiple formats, including:
JSON
CSV
Excel
SQL-compatible dumps
Binary archive formats
This ensures portability, backup, and integration with external systems — without vendor lock-in.
Default Local Storage
By default, all user data is saved in structured file formats on the local device where CitizenssApp is installed. This default provides offline access and ensures ownership. However, users can configure alternative storage targets as needed — such as cloud sync folders, databases, or enterprise file systems.
This storage model empowers users to capture and manage information in a way that is secure, flexible, and entirely under their control.
The focus remains on simplicity at the point of entry and power at the point of integration.
- Prompt-Driven AI Querying and Schema Generation: A standout feature of CitizenssApp is its integration of AI to make table interactions even more natural. Users can describe what they want in plain language – whether it’s a query to retrieve information or a specification for a new table – and the system’s prompt/AI engine will handle the technical translation. For example, a user might ask, “Show me all customers who signed up this month and their purchase totals,” and the platform’s AI can generate the appropriate SQL SELECT join query behind the scenes. This is essentially a text-to-SQL capability, an area of active research and growing real-world use. Large language models (LLMs) have demonstrated an impressive ability to serve as natural language interfaces to databases (NLIDBs), converting user questions into executable queries. Surveys find that integrating LLMs in text-to-SQL systems can “bring unique opportunities and improvements” to accessibility of data, helping bridge the gap for non-technical users. CitizenssApp builds on these advances to let users retrieve and manipulate data simply by asking, without needing to know the SQL language.
But the AI integration goes further – it also assists in schema generation and data modeling. Users can literally prompt the system with a description of an application or data structure they need, and the AI will propose a table schema (or even a set of related tables) to match. This is a huge leap in approachability: instead of manually deciding tables, columns, and types (or using a separate ER diagramming tool), a user might say “I need to track students, with their name, age, and a list of courses”, and CitizenssApp will create the appropriate tables (e.g. a Students table and maybe an Enrollment table for courses) on the fly. Recent developments in multi-modal LLMs by industry leaders show exactly this workflow is feasible – for instance, Google researchers demonstrate passing inputs like text and even images of ER diagrams into an LLM (Gemini) to automatically “suggest or even generate schema layouts, simplifying the laborious process of implementing the data model”. CitizenssApp leverages such capabilities to make the Prompt-to-Schema pipeline seamless: the user describes requirements, the LLM outputs a Data Definition (in JSON or SQL), and the platform instantiates those tables.
Prompt-to-schema generation pipeline. In this pipeline, a user’s natural language request (e.g. “Create a student table with Name and Age”) is parsed by an AI co-pilot that generates the structured metadata for the new table (Key Value Pair). CitizenssApp then automatically creates the table and integrates it into the app. By iterating with further prompts (e.g. “Add an Enrollment table linked to Students”), users can progressively design a complex schema conversationally, with the AI handling the syntax. This dramatically lowers the barrier for robust database design; it’s like having a smart assistant who instantly converts your ideas into working app components. The prompt-driven approach also covers querying and reporting – users can ask questions in plain English and get answers or charts as if they were using a search engine, while under the hood the system ensures the accuracy by pulling live data (thus avoiding the hallucination problem by grounding answers in the database). The combination of natural language interfaces with the structured transparency of TCR is potent: the AI makes it easy to generate content, but all results become tangible tables that the user can inspect and tweak, thereby remaining in control. This aligns with the platform’s ethos of AI as a co-pilot, not a black box. For instance, if the AI creates a table schema, the user can review that schema in the metadata tables and adjust any columns if needed – effectively collaborating with the AI. This synergy of AI and tabular data is forward-looking: it suggests even non-programmers can perform sophisticated tasks like designing a new app database in minutes, something traditionally requiring an experienced engineer. Google’s work with BigQuery confirms this direction, noting that flexible, modular data models can be created by multimodal LLMs in a few steps. Likewise, text-to-SQL research indicates an NLIDB can empower “non-skilled users to access structured databases like professional DB engineers”, making data more democratic. CitizenssApp incorporates these advancements to truly let prompts drive the process – from schema creation to data analysis – amplifying user productivity and lowering the learning curve.
- Multilevel and Nested TCR Structures (Metadata Modeling): While simplicity is paramount, CitizenssApp also recognizes that real-world data can be hierarchical or linked in complex ways. The platform supports multilevel and nested structures of tables, all still within the TCR framework. This is achieved through a flexible metadata model (codenamed PayanarssType in the research prototype) that can describe not only flat tables but also relationships between tables – including parent-child hierarchies, many-to-many links, and even arbitrary graph structures of data entities[14]. In practice, this means users are not limited to a single spreadsheet or flat list; they can create, for example, a Department table with a nested sub-table of Employees, or a Projects table that links to Tasks and Subtasks, and so on, to any depth needed. The metadata model captures these relationships with fields like parent IDs, types, and attributes for each entity[15][16]. Because the entire schema is represented in tables, the notion of nesting simply becomes another set of rows linking one table to another. CitizenssApp’s UI will then allow navigation or display of these nested levels in an intuitive way (for instance, showing sub-records indented under a record, or enabling drill-down views – similar to how a tree or graph of data might appear in an outline). This capability is crucial for modeling real-world scenarios that are hierarchical (think organizational charts, file directories, categories and subcategories, etc.) or networked (like social graphs or linked datasets). Traditional spreadsheets struggle with this – they are essentially 2D grids. Traditional databases handle it via foreign keys and join tables, but that requires schema planning. CitizenssApp gives the best of both: the user can add a hierarchy or relationship on the fly (just by adding a reference in the metadata that one table is parent of another), and the system will enforce and present it accordingly. The PayanarssType structure ensures consistency and referential integrity beneath the surface. This approach echoes the concept of metadata-driven schema used in some enterprise tools: for example, Salesforce’s platform uses metadata to define object relationships, and low-code tools often allow “object” definitions that include fields and links. CitizenssApp’s innovation is making this both dynamic and user-facing – the user directly edits the metadata if they want, as opposed to filling forms in a closed designer. Academic context also supports the value of such dynamic modeling: metadata-driven systems can adapt to evolving data needs more easily than hardcoded schemas. By enabling multiple hierarchical relationships, CitizenssApp can represent complex data architectures (trees, graphs, cross-links) within a single coherent TCR universe[17]. This is part of treating “LCNC (low-code/no-code) as table-first” – rather than forcing visual ER diagrams or code, everything is a table that defines another table[18][19]. For the user, it feels like extending a spreadsheet with new tabs that reference each other, except with much more powerful linkages and without the spaghetti of cell references. All of this is done in plain sight: “all metadata can be stored, shared, and versioned easily” because it’s in a tabular format[20]. That opens up possibilities like exporting your entire app schema as a simple JSON or CSV, or applying version control to your app’s structure – things rarely possible with GUI-based app builders.