Updated October 2026. The blueprint has moved on since I first wrote this: the rules now live in the contracts themselves, the checks prove they fire, the smallest honest pilot has been rehearsed end to end on synthetic records, and all of it can now be explored in your browser. The sections below say what changed, including a leak the rehearsal caught in its own public report.
Human survival should not depend on financial access. I'm building the Social Resource Floor because I believe there should be an open, shared way for a person to reach the resources they need to stay alive (food, water, housing, energy, healthcare), grounded in being human rather than in what they can pay. The blueprint is now complete, and this is why it exists, how it's built, and how far it has come. The deeper technical walkthrough lives in the companion article on dev.to.
The gap above the safety net
For most people, survival routes through financial access. To reach food, housing, energy, or healthcare you generally need money, and to hold or move money you need banking, employment, or purchasing power. Financial access has quietly become the gate standing in front of the resources a person needs to stay alive.
The delivery systems that carry social protection already exist, and they are strong. OpenSPP orchestrates programs and registries; OpenG2P provides delivery rails; OpenCRVS handles civil registration. What I could not find was an open, shared layer above them: something that coordinates one person's whole survival floor across many providers and many resource types at once, so that help can find a person no matter which organizations happen to serve them. The Social Resource Floor is my attempt to define that missing layer.
A coordination layer, not a replacement
The Floor is not a new delivery system, and it is not a rival to the platforms above. It sits over them as a coordination layer. Its job is to let independent systems (government programs, municipalities, NGOs, cooperatives, community providers) coordinate access to survival resources through shared, open interfaces, while every one of them keeps its own mission, its own rules, and its own data.
That position dictates everything else. A layer that sits above independently-run systems and coordinates them without owning them has a very particular set of constraints, and each design choice below is an answer to one of them. The same structure has to serve a single community provider running alone and a union of many governments joined under one shared floor, without changing shape between the two.
The choices that keep it honest
The first is that the blueprint is a set of contracts, not a product. The source of truth is a collection of language-neutral schemas; the implementations exist only to demonstrate them, and nothing in the project is allowed to depend on them. The rule I hold to is interface over implementation: the blueprint says what a component must be able to do, never which software must do it. If an implementation were the source of truth, then "conformant" would quietly come to mean "matches my code," and every participant would inherit my choices of language and stack. Keeping the contracts authoritative is what lets someone else build to them independently and still interoperate.
That principle reached further than I first applied it. Rules the schema standard can't express, such as "this provider must exist," first lived inside my two checkers, which quietly made the checkers part of the contract. Now the schemas declare those rules themselves, beside the fields they govern, and both checkers read them from there. A new rule is a contract edit, not a code change.
The second is that personal data stays out of the coordination layer entirely. A layer coordinating across many providers is a tempting place for personal information to pile up, and that would be exactly the wrong outcome for a system meant to serve vulnerable people. So a subject is referenced only through an opaque, pseudonymous handle that means "the same person, consistently, across the documents that need to line up," and nothing more. It carries no name, no cleartext ID number, no readable date of birth. Turning that handle into real facts about a person is done by the identity systems that already do it, entirely outside the Floor. The coordination layer never holds the answer, only the opaque reference.
Messages broadcast between systems follow the same rule. Each type of event has a closed list of what it may carry, and a failed delivery's reason is a code rather than free text, because a note written for a colleague is exactly where a name or an address slips in.
Building on what already works
The most consistent decision across the whole blueprint is that I tried to invent as little as possible. Before defining anything, I checked whether a mature standard or an existing system already solved it, and bound to that instead of building a parallel version.
The Floor does not define its own rules language for eligibility; it defines the interface a policy engine sits behind, so established engines can be bound and swapped without anything downstream changing. Consent is modeled on the W3C Data Privacy Vocabulary and ISO/IEC TS 27560: a specific, auditable record tied to a purpose, not a yes/no flag on a person's file. Identity binds to the existing convergence and credential standards rather than issuing identifiers of its own. Cross-provider authorization binds to the same machine-to-machine access patterns these systems already use.
The way participants declare and discover what they can do follows a model already proven in production elsewhere, where each participant implements only the parts relevant to its role. Those declarations are now held to account: every event names the provider that published it, and a provider that publishes an event type it never declared is refused.
The reason for that discipline is partly humility and partly durability. A coordination layer that reinvented consent, identity, and policy would be both arrogant about excellent work others have already done and brittle against the very systems it is meant to sit above. Binding to established interfaces lets the Floor inherit their maturity and stay swappable as they evolve.
Proving it can be built by anyone, not just by me
A blueprint that says "anyone can implement these interfaces" is making a claim, and I wanted that claim to be testable rather than taken on faith. So the contracts come with a conformance suite: example documents that must be accepted, and documents that must be rejected, each rejection pinned to one exact reason. The suite checks structure, checks that references between records actually resolve, and enforces every rule the schemas declare, including how much a public transparency report may say, so that it cannot re-identify anyone.
Hand-written examples only prove a rule fires once, so a mutation sweep also breaks every valid example in every way its rules allow, one change at a time, and requires each break to be caught by the rule it breaks. A coverage check fails the suite if any declared rule is never seen firing.
To check that the contracts are genuinely implementation-independent, and not just "whatever my checker happens to accept," there are two separate conformance runners over the same schemas: one in Python, one in Node, each using a different validation engine. A script runs both and confirms they reach an identical verdict on every check. Today they agree on all 427 verdicts, covering 144 example documents, 433 generated mutations, and two scenarios with 44 deliberate breakages between them. I verified that the comparison actually fails when the two are deliberately made to disagree, so the check is doing real work.
That comparison earned its place quickly. Once format checking was switched on, the two engines turned out to disagree about five kinds of value, from a timestamp with a leap second to Arabic-Indic digits in a version number, and the suite had been green on top of all five. The contracts now rule out every disputed form, and each one has an example that keeps the cross-check watching. Interoperability, at least at the level of the contracts, is something I can demonstrate rather than merely assert.
Rehearsing the smallest honest pilot
The first version ended by naming the next step: one locality, one resource type, one path from end to end, consent-gated and transparent. That pilot now runs in CI, on invented records.
A national agency publishes a food resource, and a community kitchen discovers and fulfills it. Three households give consent and are assessed. Two are found eligible; one collects and one doesn't; and one later withdraws consent, which must not unmake the decision it already allowed. A public report closes the quarter.
Every success criterion is an executable check, with a deliberate breakage it must catch. Both implementations replay the rehearsal through their own interfaces, refuse what a live floor must refuse, and end with identical records and the same public report.
What the rehearsal caught
The rehearsal's first public report passed every check and still leaked. It suppressed each small breakdown, but a hidden part that is the only part of its figure equals the figure, so hiding it hid nothing. Anyone who knew one of the two households could read off what happened to the other.
So the report now follows one named disclosure method, which I called srf-sdc-1, and it works by saying less. It publishes one figure, the distinct households a provider reached in a quarter, only once that figure reaches 10, and then rounded to a multiple of 5. Its one breakdown appears whole or not at all.
Reports come on a fixed schedule and are never rewritten, so a report's existence never signals that something happened. A new check derives every report again from the records and requires an exact match, which turns "the report carries no individual" from a claim into something CI proves. The honest cost is a thin report: a real pilot needs ten households in a quarter before any count appears at all.
I then asked for an independent, adversarial review of that change, and it found two more gaps: a protection for small, countable groups that late-arriving records could slip past, and branches of the method that no test ever reached, so deleting them left everything green. Both are fixed, and a second scenario now exists so that removing any branch turns CI red. A check that can't fail isn't proving anything, and I'd rather the tool be true than impressive.
What it is, and what it isn't yet
I want to be precise about scope, because a mission like this is easy to overstate. What exists today is a coherent, language-neutral contract for coordinating survival resources across independent providers; a suite that makes "implementable" testable and proves its own rules fire; a demonstration, checked by two independent implementations, that the contracts rather than one codebase decide what counts as conformant; and a rehearsal showing those contracts can carry a small pilot end to end.
You can check that for yourself in the Blueprint Explorer. It shows the contracts, the rehearsed pilot and each deliberate change the suite uses to test it as pictures, and it runs the same conformance runner in your browser, with nothing to install.
What does not yet exist is a running network, a governance body, or a funded pilot, and the rehearsal's records are invented. Two implementations that I wrote agreeing is a strong signal, but it is not the same as two separate organizations interoperating in the real world. The next steps follow directly from that gap: an independent party running the same suite against their own system, and the real pilot, in a real place, to show the small thing works before anyone claims the large thing does.
This is deferred, not abandoned: build the shared understanding and the open contracts first, ship the smallest useful slice, and earn the standing to propose the larger structure to the institutions that would actually run it.
The hope: a floor that follows the person
My hope reaches further than any one project. I want to see this kind of infrastructure grow into a genuinely universal floor, one where every human being, anywhere, can reach the resources they need to survive, not as charity that can be withdrawn and not as a privilege earned by geography or paperwork, but as something that follows the person wherever they are.
This is not a new idea. It is written into Article 25 of the Universal Declaration of Human Rights, which recognizes everyone's right to a standard of living adequate for their health and well-being. What has changed is that open, interoperable systems can now talk to one another across borders and agencies, so that help can find a person no matter which line on a map they are standing on. I do not imagine one platform delivering that. I imagine many open systems, built and maintained by people all over the world, agreeing to work together. A coordination layer like the Floor is one honest attempt at the shape that agreement could take.
So if one idea survives this whole essay, let it be this:
A floor beneath which no person should fall will not build itself. It has to be defined clearly enough that others can build on it (contract by contract, fix by fix, provider by provider) by people who decided it was worth building.
I would rather help build toward that than wait for someone else to.