The Case for Public Investment in Open Source Civic Tools

…

…”
}

Let me write the html with escaped quotes. Attributes: src=”…” alt=”…” loading=”lazy” href=”…”. All double quotes escaped as “. In-text curly quotes “ ” don’t need escaping.

Let me write it out fully now, carefully.

Also one small thing: “the word “open.”” — using curly quotes around open. Good.

In the skeptics bullet: ““Open” is not a quality mark.” — bullet starts with a quoted word, fine.

Also check the phrase “half promise” — fine.

Also I should double-check “screens out” usage twice (“people the system screens out” appears in fine print bullet and conclusion “pay the people it screens out”) — mild repetition, human. Fine.

Also “hostage procurement” and “hostage pricing” — nice motif.

Let me make sure the word “vendor” isn’t overused to the point of mechanical repetition. It appears ~8 times across 2000 words. Fine.

Final word count ~1950. Good.

One more consideration on the h2 “What Open Source Civic Tools Are” — answer-first definition. Good.

Also, should I include a “Key answer” box at top for answer-first? The intro already answers. Fine.

Write final JSON now. No markdown fences per “Return strict JSON only”? The user’s message shows “Return strict JSON only”. The system prompt says “Return only valid JSON.” I’ll output raw JSON. Hmm, but many of these tasks are parsed either way. Raw JSON it is. Actually, let me reconsider: the conversation includes the user message ending with the task; the assistant should output just the JSON object. Yes, raw JSON.

Careful: JSON strings must not contain unescaped newlines. I’ll put the entire HTML on one line. That’s fine.

Let me assemble.{“title”:”The Case for Public Investment in Open Source Civic Tools”,”html”:”

Public agencies in the United States spend tens of billions of dollars a year on software, and a lot of that money buys systems the public cannot inspect, cannot leave, and cannot fix. When the software that decides who eats, who votes, and who exists in the eyes of the state belongs to a vendor rather than to the public, accountability turns into a contract negotiation. The case for public investment in open source civic tools does not rest on open code being cheaper or magically better. It rests on ownership: public money should buy tools the public can see, adapt, and walk away from. Money without conditions just relocates vendor capture from the contract to the codebase.

This piece makes the case, names the conditions that make the money worth spending, and takes the skeptics seriously. In civic technology, the skeptics are usually right.

What Open Source Civic Tools Are

Open source civic tools are software systems with publicly licensed code, licensed so that anyone can use, study, modify, and redistribute it, that perform public functions: election administration and voter registration, benefits eligibility and case management, digital identity, records and permitting, constituent services, participatory budgeting. Practitioners use several overlapping labels for this space, including civic tech, public code, digital public infrastructure, and community-owned infrastructure. The labels differ in emphasis, but they share one premise: the software that runs public life is infrastructure that belongs to the public, not a product the public rents.

The definition matters because the label gets borrowed. A vendor with a public dashboard and a private eligibility engine is not running open civic infrastructure; it is running a marketing campaign. The test is whether the code that makes consequential decisions (the eligibility rules engine, the identity matching logic, the voter list maintenance process) is public, and whether the public can change it. If the answer is no, the tool is not open in any sense that matters for accountability. The Open Source Initiative’s definition of the licenses is the standard reference for what counts.

Why the Market Underprovides Civic Software

The case for public investment starts with a market failure, not with enthusiasm for the word “open.” Three mechanisms keep private markets from supplying good civic software.

• Procurement rewards incumbents. Switching costs keep agencies tied to failing systems. Data sits in proprietary formats, staff are trained on one platform, and integration work is sunk into one vendor, so leaving costs more than enduring.
• Maintenance is invisible to the buyer. Ribbon cuttings get press coverage. Patching does not. Grants fund builds and skip the decade of upkeep that follows, so tools decay the moment attention moves on.
• The people most affected are not the customers. Benefits applicants, voters with disabilities, people without stable housing or ID, and residents who speak a first language other than English never sign these contracts. Their needs get deprioritized because they hold no purchasing power in this market.

That third mechanism is where exclusion gets manufactured. An eligibility system built for the caseworker’s convenience and the vendor’s margins will produce denial rates, appeal backlogs, and error patterns concentrated on the people least able to fight back. The software is policy written in code. Policy written in private code cannot be contested in public.

What Public Investment Actually Buys

Public money for open civic tools is not charity, and it is not an indulgence for enthusiasts. It buys four concrete things.

Auditability

When code decides benefits, ballots, and identity, the governed have to be able to read the rules. Open code is the precondition for algorithmic accountability: advocates, journalists, and courts cannot contest what they cannot inspect. Proprietary eligibility logic forces every challenge through the vendor’s legal department. Public code lets a legal aid attorney read the denial logic directly, and the same holds for digital ID systems, where matching thresholds and document requirements quietly decide who counts as a person. Determinations like that should never live behind a trade secret.

Exit and bargaining power

Open licenses and open data formats lower switching costs, which is the only reliable cure for hostage procurement. The Public Money, Public Code campaign, run by the Free Software Foundation Europe, has pressed legislatures across Europe to make public licensing the default for publicly funded software, so an agency can leave a bad vendor without buying back its own data. Exit rights are bargaining rights. An agency that can walk away negotiates better maintenance terms on day one. I have sat through enough procurement debriefs to know that most agencies discover the cost of leaving only when they need to leave.

Reuse

Public money should not buy the same registration system, permitting portal, or records tool three thousand times over. One jurisdiction’s fix becomes every jurisdiction’s free upgrade, and the savings show up where they are scarcest: small counties, townships, and city agencies that will never have procurement clout on their own.

Local capacity and community power

Funding staff to steward public code keeps skills in the agency and the community instead of exporting them to contractors. It also opens a door that closed systems keep shut. Residents, community organizations, and unions can propose changes, build on the code, and hold the roadmap to account. Community-owned infrastructure is a governance arrangement, not a slogan, and it has to be funded like one.

The Fine Print: Conditions That Make the Money Worth Spending

Public investment in open civic tools fails in predictable ways, and every failure mode has a funding condition attached to it. A budget request that omits these conditions is asking for a subsidy.

• Fund maintenance, not just builds. Most grant-funded civic tools die when the grant ends. Budget the decade, not the launch: security response, dependency updates, accessibility fixes, and user support.
• Put governance in writing. Who holds commit rights? Who sets the roadmap, an agency, a consortium, a stewarding foundation? The Foundation for Public Code has done the most useful work here, publishing a standard for public code that covers governance, documentation, and reuse so that one codebase can be trusted by many governments.
• Open the process as well as the code. A public repository with a closed decision process is a half promise. Roadmaps, backlog priorities, and change logs belong in public view.
• Attach inclusion requirements. Plain-language documentation, WCAG conformance, language access, and paid testing with the people the system screens out, starting before launch rather than after a lawsuit. Then measure what matters: denial rates, error rates, appeal reversals, and who bears them.
• Reform procurement alongside the code. Require exit clauses, data portability, and source publication in every contract. Public code without procurement reform produces open repositories and closed contracts.

None of this is exotic. It is the discipline we already apply to roads and water systems: fund the life cycle, write down who is responsible, and inspect the work.

Where the Skeptics Are Right

A field guide for skeptical practitioners has to concede what the skeptics already know.

• “Open” is not a quality mark. Plenty of open civic tools are badly built and quietly abandoned. Visibility enables audit; it does not perform it.
• Openwashing is real. Vendors publish client libraries and call the product open while the decision logic stays proprietary. Read the license on the part that makes decisions.
• Community maintenance can mean two volunteers. Unfunded commons collapse. That is an argument for funding the commons, not for avoiding them.
• Public code can encode bias. A discriminatory eligibility rule is discriminatory whatever its license. Openness makes the rule contestable; only funding and enforcement make it change.

Open source does not fix civic software on its own. What public ownership buys is standing: the right to demand fixes, and the practical means to walk away when fixes do not come.

What It Looks Like in Practice

The pattern is visible where it works. Councils in the United Kingdom run reporting tools built by mySociety. Dutch municipalities share case-management infrastructure instead of buying it a hundred times over. Election offices are slowly assembling shared registration components. Where these projects hold up, the ingredients are the same: public funding, written governance, and a steward whose job is maintenance. Where they fail, the pattern is just as consistent: a grant, a launch, a press release, and silence.

For small agencies, the entry point is not building. It is joining. Adopt an existing maintained codebase, contribute to its governance, and require exit rights in every contract, so that even the proprietary purchases stop being permanent.

FAQ

Isn’t open source civic software less secure?

Security in civic software is mostly a maintenance and governance question, and licensing is the smaller variable. Public code can be audited by anyone, which makes funded security response more effective. The major failures in government systems (legacy platforms, unpatched dependencies, sole-source emergency contracts) are failures of funding. What puts resident data at risk is an unfunded system. Whether its repository is public matters less than whether someone is paid to patch it.

Doesn’t this put vendors out of business?

It changes what they sell. Commercial firms compete on implementation, integration, and support around open codebases, the way they already do in other public infrastructure markets. What public investment ends is the hostage pricing that comes from proprietary lock-in. That is the point.

How does an agency with no budget start?

Don’t build. Join. Adopt an existing maintained commons, use the Foundation for Public Code’s standard as an internal checklist, and rewrite contract language to require source publication and data portability. The cheapest first step is procurement: exit rights cost nothing to write into the next contract and save the most when they are needed.

How do we know the investment is working?

Measure exclusion, not uptime. Denial rates by language and disability status, appeal reversals, error rates in identity matching, and time to resolution for the people the system was failing before. If those numbers are not in the quarterly report, the investment is decorative.

The Demand

Treat civic software as public infrastructure, because that is what it already is. Fund the maintenance. Write the governance into the contract. Publish the code that makes decisions. Measure who the system excludes, and pay the people it screens out to break it before launch. The public should not have to rent the machinery of its own government. With the right conditions attached to the money, it does not have to.