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, housing, energy, healthcare — grounded in being human rather than in what they can pay. The first version of the blueprint is now finished, and this is why it exists and how it's built. 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; a reference implementation exists only to demonstrate them, and nothing in the project is allowed to depend on that reference. 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 the reference 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.
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.
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. And 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.
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 isolating a single clear reason. The suite checks structure, checks that references between records actually resolve, and enforces a few safety rules the schema standard cannot express on its own — including a floor on how small a published statistic can be, so that a public transparency report cannot accidentally re-identify anyone.
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 single example. The first finished version passes at forty-four examples with both implementations in full agreement, and I verified that the comparison actually fails when the two are deliberately made to disagree, so the check is doing real work. Interoperability, at least at the level of the contracts, is something I can demonstrate rather than merely assert.
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 a demonstration — checked by two independent implementations — that the contracts, not one codebase, decide what counts as conformant.
What does not yet exist is a running network, a governance body, or a funded pilot. 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 one small, honest pilot — a single locality, a single resource type, one path from end to end, consent-gated and transparent — 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 — and 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.