AI writes the applications now — dozens of them, fast, cheap, disposable.
Source is the layer they all write to: one governed schema with validation,
permissions, lifecycles and a full audit trail enforced server-side —
generated as REST for your apps and MCP for your agents. No side doors.
validated on every writeapproval gate · humans onlyaudit AUD-1042
source. admin console — a live record, not a mockup
The problem
Every vibe-coded app ships its own database. That's how a company loses its truth.
01
Interfaces became disposable
A coding agent builds a working tool in an afternoon. Teams stop asking IT and start generating — quoting apps, dashboards, portals. The interface layer now moves at prompt speed.
02
Each one invents "customer" again
Every generated app brings its own storage, its own IDs, its own idea of what a valid record looks like. Five apps later there are five versions of the same customer — and none of them is the record.
03
Rules can't live in generated code
Validation written inside an app dies with the app — or worse, survives in eleven slightly different copies. Approval flows, permissions and audit have to sit below the apps, where regeneration can't erase them.
The interface layer became disposable. The data layer can't be.
Define the schema once. Source enforces it everywhere, for everyone.
This is not a concept page — every capability below is captured from the running product.
01 — SCHEMA
Define business objects, not tables
Customers, quotes, contracts — described once in a field designer that thinks in governance, not column types.
Three-level fields: a preset (Email, Currency, Single choice …) fills in the datatype and its rules — everything stays reviewable.
References, single and multiple: a contract belongs to one customer; a company has n contacts. Every stored ID must point at a real record.
ID rules like QUO-{year}-0001 — generated by Source, unique, immutable. No app ever invents an ID again.
field designer — screen capture
Adding a validated email field: the preset fills datatype + pattern, tested live before saving.
02 — GENERATED ACCESS
The API and the agent tools fall out of the definition
Activate an object and its access exists — immediately, no deploy, no endpoint code.
REST + OpenAPI for every application, with per-field validation errors an app can show directly in its forms.
MCP tools for every agent: list_quotes, create_quote, transition_quote — same rules, same permissions, no side door.
llms.txt + per-app quickstarts: your coding agent reads how to integrate correctly instead of guessing.
machine access — generated, liveno endpoint code
# REST — served the moment the object is activeGET /api/v1/quotes?status=review
POST /api/v1/quotes # 422s name the exact fieldPOST /api/v1/quotes/{id}/transition {"to":"review"}# MCP — the same objects, as agent toolslist_quotes · get_quote · create_quote · update_quote · transition_quote# and the contract agents can readGET /api/v1/openapi.json · GET /llms.txt
03 — GOVERNANCE ON EVERY WRITE
The rules say no — politely, and to everyone
Every create, update and transition passes the same governed write path, whether it comes from a human, an app or an agent.
Lifecycles on any single-choice field — several per object. Only defined transitions exist; approval gates stay with humans, agents can never pass them.
Conditional rules: "status is review AND amount is empty" blocks the move into review — with a message the user actually understands.
Blocked ≠ failed: illegal moves return a corrective hint ("Move it to review first"), so agents self-correct instead of retrying blindly.
lifecycle enforcement — screen capture
An illegal jump is rejected with the legal path; the legal move goes through — audited.
04 — AUDIT
Who did what, through which app — always answerable
Every write lands in the audit log with actor, role, interface, application and the before/after diff. Denied attempts too — governance you can prove, not just claim.
Identity × application × environment on every entry — including the end user an app reports.
History is history: records are never deleted, they close via lifecycle states; even ID-format migrations keep historical IDs in the trail.
Events + signed webhooks when records change state — automations react to truth, not to polling.
audit log — real screenshot
05 — EVOLUTION WITHOUT BREAKAGE
The schema changes. The data survives.
Schema changes that could strand stored records force an explicit decision — never a silent divergence.
Value migrations: removing a list value that records still hold asks for a replacement — and converts the records along.
ID conversions rewrite every record and every reference from other objects in one transaction.
Sub-objects: derive Employment Contract from Contract — fields, lifecycle and rules copied once, lineage recorded, full independence after.
business objects — real screenshot
See it live
Not slides. The product.
Every capture on this page is taken from the running console against real, governed records.
Governance says no — with a hint
An illegal transition is blocked with the legal path spelled out; the legal one goes through and is audited.
A field in thirty seconds
Preset fills datatype and rules, the pattern is tested live, and the column, API and agent tools update on save.
References that can't dangle
A company links its n contacts as chips — every ID validated for existence, on this and every other interface.
The governance report
Every rule and reference across the schema — as a live dependency graph.
Lifecycles, plural
Status and approval running side by side on one object — each with its own gates.
The field designer
Datatype, governance, presets — three levels, one drawer.
From the field
Two stories we hear in almost every first conversation.
Anonymized and condensed — but if internal data lives anywhere near a coding agent, at least one of these is already happening in your company.
IT consultancy · ~150 consultantspeople & staffing data
Read-only was fine. Then the apps started writing.
01 · The setup
Skills, project assignments and CVs live in an internal database. Consultants discover coding agents and build genuinely useful tools in days: a skill search, a staffing board, a CV generator. All read-only. Everyone is delighted.
02 · Where it breaks
The staffing board gets a “reassign” button. Within weeks, three apps write to the same tables: duplicate employee records, availability overwritten with free text, one CV half-erased by a sync bug. Nobody can say which app changed what — or which number is still true.
With Source
Employees, assignments and CVs become governed objects. The apps stay vibe-coded — but every write is validated, staffing changes move through a lifecycle with a human approval gate, and the audit log names the app behind every change.
IT consultancy · internal dashboardswho may see what
The dashboards showed everything. To everyone.
01 · The setup
Same instinct, different failure: utilization, salary bands and performance notes sit in one internal database. Dashboards get vibe-coded on top — and because it was the fastest path, every app got a full database connection.
02 · Where it breaks
The utilization dashboard renders every consultant’s salary band. A project view surfaces performance notes to the whole team. No breach, no attacker — the apps simply display everything, because nothing underneath them knows who is allowed to see what.
With Source
Every app registers first and is scoped to the objects it may touch — salary data simply isn’t in the dashboard’s scope, and the agent that builds it never even sees the tool. Who may read what is decided once, below the apps, and enforced server-side on every request.
Both teams did the right thing: they let people build. The layer underneath just wasn't ready for it.
Your coding agent gets a prompt. Not a database connection.
Every consumer registers as an application before it touches data. The setup wizard walks from registration to a working integration in minutes:
01 registerName the app — web app, Power App, agent or integration.
02 scopePick the objects it may touch. Everything else returns 403 — and agents don't even see the tools.
03 keyIssue a key bound to app × identity × environment. Disable the app, and every key dies with it.
04 buildCopy the generated quickstart into your coding agent — endpoints, rules and examples scoped to exactly this app.
The app can be wrong. Your data still can't be.
application registry — real screenshot
Where it runs
Your data stays where you decide.
PostgreSQL under the hood. Environments as first-class citizens — sandbox to production, with schema promotion along the pipeline.
EU CLOUD
Source Cloud EU
Managed by us, hosted exclusively in EU datacenters. The fastest path from schema to production.
AWS / AZURE
Your cloud account
Deploy into your own VPC and subscription. Your keys, your region, your controls.
STACKIT
German sovereign cloud
For data that may not leave EU jurisdiction — including the operator.
ON-PREM
Self-hosted
Kubernetes/Helm with full feature parity. Sovereignty without a feature tax.
Pricing
You pay when data changes. Reading is free.
Source meters exactly one thing: governed writes — every create, update and lifecycle transition that passes the write path. No seats, no per-app fees: humans, apps and agents are unlimited on every plan.
Metered
1 governed write = one create, update or transition — validated, permission-checked, audited.
Free
Reads, list queries, OpenAPI and MCP tool discovery — unlimited on every plan.
Also free
Blocked writes. Governance saying no is the product working, not a billable event.
From live usage
The median early-access workspace runs ~31,000 governed writes a month — inside Platform's included volume.
Sandbox
€0
Evaluate Source on your own machine or a dev server — the full engine, not a demo tier.
2,500 governed writes / month
1 development environment
Full governance engine — schema, lifecycles, rules, audit
€290 / month€290 base — inside the 50,000 included writes
Drag to your expected volume. Writes are what agents and apps change — reads, dashboards and lookups never count.
Early-access pricing — locked in for early customers when we hit GA. Metering follows our own compute: what costs us is validating and auditing writes, so that's the only thing we charge for.
Fair pushback
You should be skeptical. Here's where we stand.
The questions sharp CTOs actually ask us — with the answers we give on the call, not the ones from a pitch deck.
“If frontends become a commodity, backends are next. Won't AI just generate this layer too?”
It already can — and that's exactly the problem. A coding agent will happily generate a backend per app, which is how you end up with eleven backends and eleven versions of the truth. The code was never the point.
A system of record is valuable because there is exactly one — one schema, one write path, one audit trail. “One” is the single thing per-app generation cannot produce. Source is deliberately the layer you don't regenerate, so the rules survive every app that comes and goes above it.
“We already run PostgreSQL. Isn't this a database with extra steps?”
It is PostgreSQL underneath. But a connection string enforces nothing: any client with credentials can write anything, in any shape, with no trace of who or why.
The extra steps are the product — validation, permissions, lifecycles and audit on every single write. Skip Source and those steps don't disappear; they get reimplemented, slightly differently, inside every generated app.
“Our ERP / CRM is already the system of record.”
For the processes it owns — yes, keep it. But vibe-coded apps don't write to your ERP; its API is where enthusiasm goes to die. So they write around it, into their own storage, and that shadow data never makes it back.
Source governs the long tail of objects your ERP was never going to model — quotes, staffing, approvals, internal ops — and signed webhooks keep the ERP informed instead of bypassed.
“Can't we just prompt our agents to follow the rules?”
A prompt is a request. Enforcement is a property of the layer below. Agents drift, lose context and can be prompt-injected — and a rule that lives in a prompt dies with the next rewrite of that prompt.
Source doesn't rely on cooperation: an illegal write is rejected with a corrective hint the agent can act on, and approval gates stay with humans no matter what any prompt says.
“One more platform — isn't that just new lock-in?”
Your data sits in PostgreSQL — in our EU cloud, your cloud account or on your own metal. Access is plain REST, OpenAPI and MCP; exports are yours any time. If you leave, you leave with a Postgres database and an OpenAPI spec.
Compare that to the actual lock-in scenario: your truth scattered across eleven app databases nobody dares to touch.
“Won't governance slow people down? We like that anyone can just build.”
So do we — the stories above don't end with “stop building.” They end with building more, safely. Every new app inherits validation, permissions and audit instead of reinventing them, and the generated quickstart takes a coding agent from zero to a correct integration in minutes.
Governance here isn't a review board. It's defaults the apps are born with.
Next step
Talk to the founder.
No SDR, no discovery-call theater. You talk to the person who builds Source — on the live product, with your data problem on the table.
TM
Tom Müller
Founder — Source · ARES Consulting
30 minutes, live on the running platform — the same one captured on this page
Bring one messy, real process (quotes, contracts, approvals) — we model it together
Honest answers on maturity: what's production-ready, what's roadmap
