Software Design and Government

Software and Government have a lot in common when it comes to history and design. Let’s start with Software.

When first building a new Software project, you design it to do one thing well. The project starts small doing 1–2 things well and a small userbase. As users give you feedback, you hire more developers, add more features and build up a complex application which serves the needs of a moderate sized user base. Now as you grow in popularity your app reaches a large userbase and is even more complex. If you are like most startups, you are still working on a single architecture scaling by buying more servers. At some point, you reach a point where you cannot grow. Scaling becomes really hard since small changes change the whole infrastructure. So what do you do? You scale by breaking your application apart into smaller subsidiaries with well defined missions. You provide a platform for your applications to be deployed on, but each team becomes responsible for their projects from start to finish, from launch, to retirement. This allows you to scale since adding new feature means just building a new team. No longer are you stuck all trying to build on the same platform.

Now let’s talk about government. Government started small. City-States to be exact. Individuals lived within city walls to be protected from foreign invaders and government thrived. Cities collaborated and thus was birthed the state. States grew in popularity until we reached a point where multiple states wanted to provide open borders and free trade and thus was born the United States. The United States government too was simple at first with most of the power being relegated to local districts with a pyramid of tasks up to the federal government, but after WW2, the US federal government has ballooned. Now there are vast beaucracies covering everything from healthcare to education, from self defense to banking regulations. At the same time, Americans love to compare the US to small states which provide tons of services seemingly without all the bureaucracy.

So what can Government do? The same thing that software companies do. Build a solid platform to start with, distribute services to the nodes and remove duplication and unnecessary overhead. This allows governments to scale efficiently.

Let’s talk about what that might look like in the US with something like education.

“The primary functions of the Department of Education are to ‘establish policy for, administer and coordinate most federal assistance to education, collect data on US schools, and to enforce federal educational laws regarding privacy and civil rights.’ The Department of Education does not establish schools or colleges.” (

Common Core is a federal standard set to provide guidelines on how to educate. The problem in this instance is that the user base (students) vary significantly socioeconomically and thus a single standard aimed at a one size fits all solution doesn’t work. In software it isn’t enough to set standards, you need to provide tools and resources to succeed. Also, there is the consideration that regions have different tax revenue streams meaning some kids could be underfunded in poor areas. However, it would also be a failure if students in richer areas simply went to private schools and lived in cities with no property taxes (which are usually the main source of school funding).

So how do you solve this using patterns in Software Engineering? Imagine you have distributed servers with varying amounts of resources (CPU time, memory, etc). You would deliver software capable of running on the least powerful machine and offload anything that needs more capacity to a machine with more resources or even just a centralized machine. In other words, for those machines with lower resources, you subsidize the machine by performing the work outside.

How might this work for Education? From 2011–2014, the US spent around $13,000 per student for High school. In a perfectly equal society, counties can simply put property taxes to be roughly equal to this amount divided by the number of households, but this doesn’t always work. So let’s do it this way.
1. Set a standardized property tax rate minimum with half going to the federal budget. Rich communities now fully pay their schooling, while poorer cities are still contributing. 
2. Use any extra funds to subsidize the remaining costs at poorer districts.

Now this solves the funding problem, but funding isn’t everything.
3. Give parents vouchers to take the money to any school. 
4. Allow parents to pay above the voucher to go to elite schools.

In software, websites don’t dictate how the CPU is used on the end client, the client does that. Similarly, individuals are the best people at choosing how to spend education resources. Also, some individuals have better performing computers. You don’t lower the experience overall to make them have a worse one, instead you allow them to use the resources they have to increase what they can.

Now, we have a system which scales, is equitable, is efficient at using existing resources, and reduces overhead significantly (no more federal beauracrats).

However, now we get a different problem. As our users use the system, some students perform significantly better than others. There is voucher fraud and a lack of oversight. So how do we solve this? Re-install the beaucrats? Unlikely to do anything. This is where standards come in place. So how do we set standards? The same way internet standards are created, via collaboration. Have all schools in a county come together and define standards like grades, school terms, rating systems, discipline, and find common ground. Then a rep takes those standards to the state level and does the same thing, except they also take back recommendations from other cities and tries to adopt them. If there is a majority adoption of a standard for a county, it gets adopted county wide. Then finally, states take their standards and have a national convention. Standards are then adopted nationally with a super majority approval (> 75%). Have a federal meeting once a year, state meetings twice a year (pre-post federal meeting), county meetings 4 times a year (pre/post state meetings), and city meetings 8 times a year (pre/post county meetings).

What do the standards do? They allow students to transition smoothly between schools. They ensure that students follow a similar learning schedule anywhere. And since these standards are collaborated, no school feels like they are unheard, they can set standards locally and share their success/failure before adoption at the next level.

As government processes become more and more transparent, we have a unique opportunity to apply the learnings of software to make a better government.

Like what you read? Give Michael Darmousseh a round of applause.

From a quick cheer to a standing ovation, clap to show how much you enjoyed this story.