Method: The free-resources atlas and guides

A resident who needs free or subsidized help — food, transit, internet, legal aid, whatever it is — does not need our opinions. They need a list that is actually current, actually free, and actually reachable. This page is how we build and keep that list, and how we turn it into guides a person can read without wading through a spreadsheet.

What it produces

Two things, tied together. First, a registry: every free or subsidized resource we’ve found, one row each, with what it is, who it’s for, and how we last confirmed it’s still real. Second, a set of readable guide pages built on top of that registry — grouped by need, written in plain language, and published only once they’ve cleared our checks. Nothing gets a public page until it has passed those checks; anything still short of that bar is named on the index as not yet published, never quietly left off.

How it works, step by step

Finding candidates. We work through likely sources — city and agency listings, provincial and federal programs, community organizations, and resources residents themselves point us to — and add each one as a candidate row.
Recording where a resource came from. When a candidate comes from a document someone has shared with us, we log what it is, who published it, and when, before we mine anything out of it. That record travels with the resource for as long as it’s in the registry.
Merging into one registry. Everything found gets consolidated into a single list of record, so the same resource never lives in two disconnected places with two different answers about whether it’s still active.
A mechanical check after every addition. Before anything moves forward, an automated check runs over the registry looking for two kinds of problems: duplicate entries, and rows that are missing information they’re supposed to have. This isn’t a judgment call — it’s a hard, repeatable check, and a bad result stops the process until it’s fixed or an operator explicitly says otherwise, on the record.
A legal read before anything goes public. Any row flagged as needing a closer look before publication — for instance, something copied from a source whose rights to republish are unclear — is held out of every public guide until that flag is cleared.
Building the guides. Guide pages are generated directly from the sealed registry — never hand-typed from memory, never drifting from what the registry actually says. The generator does no new research and writes nothing back into the registry; it only turns checked data into a readable page.
Only finished guides publish. A guide has to be marked complete and checked before it goes live. A guide still being worked on shows up on the index as in-progress, not missing and not silently skipped.
A human holds the publish button. Before anything goes out to the public, someone reviews a plain summary of what changed and what the checks found, and gives an explicit go-ahead. Nothing publishes on its own.

How it's checked

The audit surface here is meant to be concrete enough that anyone could challenge it. The mechanical duplicate-and-completeness check runs after every batch of additions, not just before publication, and its result is pass or fail — no judgment call involved. The legal-read flag is a plain marker in the data itself, and a flagged row cannot appear in a public guide until that marker is cleared. Every resource carries its own confidence label rather than being quietly rounded up to “confirmed” — if we haven’t re-checked something recently, the guide says so instead of implying it’s current.

And here is the truth we build the whole method around: a “free and open” claim rots. Programs end, phone numbers change, eligibility rules shift, organizations close. Nothing about verifying a resource once makes it true forever. Re-checking is not a one-time gate we pass and move on from — it is a standing task built into the method, the same way a food bank has to restock every week rather than once. If you build this for your own municipality, budget for the re-checking as real, ongoing work, not a box you tick and forget.

What it honestly costs

The heavy lift is finding and confirming resources, not writing the guide pages — once the registry is solid, generating readable pages from it is comparatively quick. Expect the discovery-and-verification work to run in parallel lanes by source type (city services, other levels of government, community organizations, and so on), with one person holding final publish authority and reviewing what each pass found before anything goes live. We don’t publish a fixed hours estimate here, because it depends on the size of your municipality and how much is already documented publicly — but verification, not writing, is where the real time goes, and that is by design: the expensive part is the point.

Known limits

Some pieces of this are still informal. Exactly how candidate rows get merged from separate working lists into the single registry of record is practiced routine rather than a written procedure — it works, but a stranger couldn’t yet follow a script to reproduce it. Re-verification is named as a standing responsibility, but there is no automatic scheduler forcing it on a cadence yet — it depends on someone remembering to run the check. And the legal read is currently a marker in the data with a mechanical scan available to catch it; we have not independently reconfirmed that every possible path to publication actually calls that scan, so we say so rather than assume it.

What stays internal, and why

The full detail of which team worked which source and the raw uploaded documents we mined resources out of stay internal — they’re working material, not something a reader needs to trust the result. What’s public is the registry itself and the guides built from it, released only once they’ve passed the checks above. And one hard rule that never bends: this registry is about organizations and programs, not people. If a candidate row ever turned out to name a private individual’s personal contact information, that would be treated as a problem to fix, never a row to publish.

Want to build this for your own city? Start here: Run this in your municipality. Curious how we decide anything is true before we publish it at all? Read How we verify.

— The Unknown Soldier · uniteTOlove · Toronto