In the 1920s, General Motors realized that if it made vehicles harder to repair, customers would buy new ones instead of fixing what they had. It was a business insight, not an engineering one. The cars weren't getting more complex because complexity served drivers. They were getting more complex because complexity served the manufacturer's revenue model.
That dynamic stayed mostly invisible for decades. Independent mechanics adapted. Shade-tree DIYers found workarounds. The system was annoying but navigable.
Then manufacturers started sealing transmissions. They started requiring proprietary diagnostic tools that only authorized dealerships could access. They started using software locks that prevented third-party parts from functioning, even when those parts were identical in every way that mattered. The work didn't get harder. Access to the work was taken away.
You bought the car. But you couldn't choose your mechanic. You couldn't choose your parts. You couldn't shop hourly rates. Everything had to flow through the manufacturer's authorized channel, at the manufacturer's price, on the manufacturer's terms. The dealership rates weren't just paying for expertise. They were paying for franchise overhead, manufacturer mandates, and a system designed to eliminate alternatives.
That tension created the Right to Repair movement.
The pattern repeats
Massachusetts passed the first automotive Right to Repair law in 2012. It required manufacturers to sell the same diagnostic tools and service materials to independent mechanics and consumers that they'd been providing exclusively to their dealership networks. The law became a template. By 2014, major automakers signed a memorandum extending those principles to all 50 states.
Then the same pattern showed up in other industries.
John Deere started locking the software on tractors so thoroughly that farmers who had repaired their own equipment for generations were told they didn't own the machine they'd paid for. They owned a license to operate it. Deere argued that opening the software would compromise safety. Farmers argued that their families had been maintaining this equipment since before Deere had a software division. The American Farm Bureau eventually secured a memorandum of understanding affirming farmers' right to repair their own equipment.
Apple started serializing iPhone components so that replacing a cracked screen with an identical Apple-manufactured part would trigger error messages and disable features, unless the replacement was done by an Apple-authorized technician. Six states have now passed Right to Repair laws covering consumer electronics.
During the COVID pandemic, hospitals couldn't get timely maintenance on ventilators because the manufacturers controlled the repair process. People were dying, and the equipment that could save them sat waiting for an authorized service visit.
Every time, the manufacturer's argument was the same: this technology is too complex for you to work on. Every time, the real issue was the same: open access threatened a profitable service monopoly.
Municipal software followed the same path
The govtech vendor ecosystem has adopted every tactic that triggered Right to Repair in other industries. But the dynamic in govtech is different, and in some ways more extreme.
Car manufacturers build the engine. John Deere designs the tractor. Apple engineers the phone. When those companies restrict access, they're at least restricting access to technology they created.
Govtech vendors, for the most part, didn't build the engine. The databases underneath their platforms are open source. The hosting is commodity cloud infrastructure anyone can rent. The interfaces are standard web technology built on open frameworks. What happened was that these accessible components were wrapped in proprietary formats, public data was locked behind terms of service that classify it as vendor-confidential information, and cities were told the technology was too specialized to manage themselves.
A mid-size city pays $14,000 a year for public records request software. That software is, at its core, a form, a queue, and a deadline tracker. The underlying technology is not $14,000 worth of complex. But the city has no way to verify otherwise, because the ability to see inside the system and understand what it actually does is locked behind the vendor's proprietary wall.
The bundling makes it worse. Vendors don't sell one product. They sell a suite: records management plus meeting software plus public notifications plus the city website plus constituent communications. Every additional product compounds the switching cost. Leaving one tool means untangling everything. The lock-in isn't a side effect. It's the business model.
And the consolidation makes it worse still. When one company acquires another, an independent alternative disappears from the market. The three largest govtech platform companies have made a combined 50-plus acquisitions. Each one removed a choice a city used to have.
Meanwhile, the tools to do the work have never been better
Here's what makes this moment different from every other time someone has argued that cities should own their technology.
Five years ago, maintaining a web application required a dedicated development team. Most municipalities couldn't justify that. The vendor model, whatever its flaws, was the only option that came with a support contract.
That's no longer true, and the shift is not incremental. It is historic.
Large language models now function as on-demand analysts, researchers, policy advisors, and software developers. Every major AI lab is racing to make code generation reliable, because code is verifiable, outcomes are testable, and that makes software development one of the highest-value applications of AI. The gap between what a vendor charges to build and what a capable team can build with AI assistance is collapsing.
Beyond AI, the broader knowledge infrastructure has transformed. Open-source communities have turned every software component into a documented building block. YouTube has turned every technical skill into a learnable one. Cloud hosting has made infrastructure a utility, not a capital expense.
The correct response to this moment is more openness, more modularity, more choice. Some companies understand this. Startups are designing vehicles meant to be owner-customizable from day one. Toyota has prototyped trucks built on what they call “deliberate incompleteness,” shipping from the factory unfinished so communities can adapt them to local needs. When tools get more capable, the right instinct is to open the hood wider.
The govtech vendor ecosystem is moving in the opposite direction. It is closing the hood at exactly the moment when the tools to work under it have never been better.
Where's the movement?
Right to Repair didn't happen because manufacturers had a change of heart. It happened because enough people (farmers, mechanics, technicians, consumers) got organized and demanded legislation. The movement named the pattern, built coalitions, and pushed until laws changed.
Municipal software doesn't have that movement yet. There's no equivalent of the Massachusetts automotive law for city data portability. No federal directive requiring govtech vendors to provide open APIs or export in non-proprietary formats. No memorandum of understanding between vendors and the municipalities they serve establishing a baseline of data rights.
There are reasons for that. Municipal procurement is fragmented across 38,000 local governments, each making independent decisions. City administrators aren't organized as a class the way farmers or auto repair shops are. And the people most affected, the residents whose data is locked in vendor systems, don't even know it's happening.
But the conditions for the movement are forming. Municipal leaders are sharing experiences through networks like City AI Connect, NLC, and ICMA. AI is forcing conversations about data ownership that vendor contracts alone never prompted. And a growing number of cities are asking a question that sounds simple but has radical implications: if we're paying for this software, why can't we see inside it?
What cities can do now
Legislation will come eventually. In the meantime, cities don't have to wait.
Start with visibility. The vendor contract analysis workflow CivicWork is building does something straightforward: it reads a vendor contract (a public document), maps it against what the vendor's website says the product does, and translates the result into plain language. What are you paying for? What's commodity technology with a compliance label? What would it cost to own this yourself? That's the diagnostic tool. Once a city sees what's inside the black box, the conversation changes.
Require data portability in new contracts. Before signing or renewing, ask: if we leave, does our data come with us? In what format? At what cost? These are reasonable questions that most vendors would prefer not to answer. Asking them anyway is the beginning of establishing norms.
Adopt governance frameworks that are vendor-independent. The Verifiability Framework and Trust Stack that CivicWork publishes are free, open, and usable without CivicWork's involvement. They give municipal leaders structured language for evaluating technology proposals on their own terms, rather than on the vendor's terms.
Build on open infrastructure where possible. Not everything needs to be replaced at once. But the next time a contract comes up for renewal, the question should be: is there an open alternative? And if so, what would it take to own it?
Cities deserve choices
Right to Repair started with a simple principle: if you bought it, you should be able to fix it. With parts you choose. With mechanics you choose. At rates that reflect the actual work.
The equivalent principle for municipal software is just as simple: if the public paid for it, the public should own it. The data should be portable. The code should be inspectable. The city should be able to choose its tools, its partners, and its terms.
That's not a radical position. It's the same standard cities apply to every other piece of public infrastructure. Nobody would accept a water treatment system where the pipes belonged to the contractor. Nobody would accept a road where the blueprints were classified as the paving company's trade secret. But cities accept exactly that arrangement for their software, every day, because the vendor ecosystem has made it feel normal.
It's not normal. It's a business model. And like every other industry where that business model pushed too far, the pushback is coming.