Congress has lost its grip on funding the government - The Washington Post

The phrase Congress has lost its grip on funding the government - The Washington Post isn't just a headline; it's a technical debt crisis that threatens every federal IT initiative. When lawmakers can't distinguish between a scalable microservices architecture and a monolithic legacy system, the federal budget becomes a dumping ground for overpriced, underdelivered software contracts. As a senior engineer who has consulted on government digital transformation projects, I have seen firsthand how the lack of congressional technical literacy turns well-intended appropriations into multi-billion-dollar boondoggles.

In this article, I will argue that Congress's inability to oversee software procurement is the single largest driver of waste in the federal budget. We will dissect the specific engineering failures behind headline-grabbing projects, explore how open source and modular contracting can restore fiscal discipline and outline what lawmakers can learn from the playbooks of companies like Google, Amazon, and Netflix. The Washington Post's diagnosis is correct. But the cure lies not in more funding - it lies in teaching Congress how to read a pull request.

The Washington Post's Diagnosis: A Systemic Failure of Technical Oversight

The Washington Post's recent coverage on Congress's fading grip on the budget builds on decades of reporting by outlets like The Washington Post's technology deskBut the real story isn't partisanship; it's incompetence. Congress has allocated over $90 billion to major IT projects since 2010. Yet a 2021 Government Accountability Office report found that 38% of those projects were considered "poorly planned" and 21% had no credible cost estimates. The root cause is that appropriations committees rarely include members with any software engineering background.

When a bill authorizes $500 million for "modernizing" an agency's database, no one in the hearing room asks: "Is this a lift-and-shift to the cloud,? Or are we refactoring the schema? " The result is that contractors deliver proprietary solutions that lock the government into decades of maintenance fees. Congress has essentially outsourced its constitutional "power of the purse" to vendors who have no incentive to ship efficient code.

My own experience on a federal IT oversight panel confirmed this. During a review of a $2 billion Department of Veterans Affairs scheduling system, I asked the project manager how they handled database migrations. The answer: "We don't. We hire contractors who do that. " That system is now a decade late and still can't schedule appointments reliably. The Washington Post's reporting on this exact pattern - that Congress has lost its grip on funding the government - isn't hyperbolic; it's a understatement.

Why Tech Projects Become Black Holes for Taxpayer Money

Government technology projects fail for three engineering-specific reasons: fixed-price contracts that reward waterfall planning, security certifications that stifle iteration. And a procurement process that treats software like concrete. In the private sector, a cloud infrastructure project might use Infrastructure as Code (IaC) tools like Terraform or Pulumi to provision resources in minutes. In the government, the same change requires a 200-page requirements document and a six-month approval cycle.

Consider the Federal Aviation Administration's NextGen air traffic control upgrade. Originally estimated at $40 billion, it has ballooned past $50 billion with no end in sight. The core problem was that the FAA mandated a single vendor to build a monolithic system from scratch, rather than decomposing the problem into modular services. This violates the fundamental engineering principle of separation of concerns. Meanwhile, the open source Kubernetes ecosystem has been orchestrating containerized workloads for years - and it costs nothing to deploy.

Another critical factor is the lack of automated testing in government contracts. In a typical agile shop, CI/CD pipelines run thousands of tests per commit. Federal contractors, however, often still rely on manual QA checklists that are updated annually. The Government Accountability Office has repeatedly flagged this. But Congress hasn't mandated any specific testing framework. Without these guardrails, every line of code becomes a liability,, and and every dollar spent yields diminishing returns

The Root Cause: Congressional Lack of Technical Literacy

It is easy to blame bureaucrats. But the real bottleneck is on Capitol Hill. The average member of Congress is a lawyer or businessperson with no formal training in computer science they're supported by staffers who are generalists. When the Congressional Budget Office (CBO) scores a tech bill, it estimates cost based on historical averages - not on architectural complexity or technical debt. This is like pricing a house based on the number of bedrooms without looking at the foundation.

There is a concrete fix: Congress should create a nonpartisan Office of Technical Assessment, similar to the one it disbanded in 1995. That office, the Office of Technology Assessment (OTA), used to provide members with rigorous analysis of topics like satellite communications and missile defense. Reinstating it would give lawmakers the same kind of engineering expertise that venture capital firms use to evaluate startups. Until then, Congress will continue to approve funding for projects that any competent software architect would reject.

I recall a briefing where a senior senator asked why a cloud migration project could not just "copy the data" to the new system. The engineers present had to explain TCP/IP, database sharding, and eventual consistency - all concepts that should have been covered in a two-hour orientation. That senator's staff later admitted they had no idea what "eventual consistency" meant. This isn't a partisan issue; it's a literacy issue. And it's why Congress has lost its grip on funding the government - The Washington Post nailed the symptom. But the cure is education.

Case Study: Healthcare gov and the Lesson Unlearned

The launch of Healthcare gov in 2013 is the canonical example of what happens when Congress funds a system without technical oversight. The initial contract was awarded to a single prime contractor (CGI Federal) using a waterfall methodology. The website crashed on day one because the database couldn't handle concurrent users - a classic scalability failure that any junior DevOps engineer could have predicted. After the Obama administration brought in a team of Silicon Valley engineers (the US Digital Service), the site was rebuilt using agile practices and open source components.

Yet nearly a decade later, the same mistakes are repeated. The recent rollout of the Affordable Care Act's expanded subsidies was plagued by a brittle legacy system that couldn't handle load. Congress had allocated $5 billion for "IT modernization" in 2022. But most of that money went to maintaining COBOL-based mainframes, and the lesson from Healthcaregov - that small, cross-functional teams building with modern frameworks like React and Node js can outperform large contractors - hasn't been institutionalized. Suggested internal link: /blog/healthcaregov-agile-lessons

What makes this especially frustrating is that the technical solution is well-documented. The US Digital Service Playbook explicitly states: "Use modular, open. And cloud-based approaches. " Congress could mandate that any IT project above $10 million must follow this playbook. But because the playbook was written by engineers - not lobbyists, it remains a suggestion rather than a requirement.

How Software Engineering Principles Can Fix Government Funding

If Congress wants to regain its grip on funding, it must adopt three engineering principles: modularity, observability. And continuous delivery. Modularity means breaking large appropriations into smaller, independently testable pieces. For example, instead of a single $1 billion "modernization" bill, Congress could authorize $20 million for a pilot that uses a specific API, then release subsequent funding only if measurable OKRs are met.

Observability means requiring contractors to provide real-time telemetry on spending and progress. In production environments, we use tools like Datadog or Grafana to monitor latency, error rates. And resource usage. Why not apply the same principle to budget execution? A simple dashboard showing burn rate - commit frequency. And test coverage would make it immediately obvious if a project is on track or heading toward disaster. The GAO's latest guide on agile procurement hints at this. But it stops short of requiring instrumentation.

Continuous delivery means that funding should follow delivery, not the other way around. Instead of appropriating three years of budget upfront, Congress could adopt a "rolling wave" model where agencies receive quarterly tranches based on demonstrated progress. This aligns incentives with the lean startup methodology: build, measure, learn. It also prevents the sunk-cost fallacy from keeping failing projects alive. I have seen this work at companies like Etsy and Netflix; there's no reason it cannot work for the Department of Defense.

The Role of Open Source and Modular Contracts

Open source software isn't just free; it is a mechanism for oversight. When the government uses a proprietary system, only the vendor knows the code quality. With open source, any engineer - including those on congressional staff - can inspect the repository. The Department of Defense's recent adoption of the Defense Innovation Unit's open source cloud platform is a step in the right direction. But Congress hasn't yet required open source licensing as a default for federally funded software.

Modular contracting, championed by teams like 18F and the U. And sDigital Service, breaks monolithic procurements into smaller, bite-sized pieces. Instead of hiring one vendor to build everything, agencies can issue 10 separate contracts for authentication, payment processing - data storage, and frontend rendering. This lowers the barrier to entry for small businesses and startups, increases competition. And reduces vendor lock-in. The Technology Transformation Services (TTS) has proven this model works. But it remains the exception rather than the rule.

Congress should pass legislation requiring that all new IT contracts over $5 million use modular, open source-friendly frameworks. This single change would fundamentally alter the incentive structure. Vendors would compete on engineering excellence rather than lobbying prowess. And Congress would finally be able to see exactly what it's paying for, restoring its grip on the flow of taxpayer dollars.

What Congress Must Do to Regain Its Grip

First, Congress must reinstate the Office of Technology Assessment. The OTA provided nonpartisan, peer-reviewed analysis of technical topics from 1972 to 1995. Its abolition was a mistake that directly correlates with the explosion of failed IT projects. Bills to revive it (e, and g, H. R, since 3709 in the 116th Congress) have stalled, but the need has never been greater. Without OTA, lawmakers will continue to be outmatched by vendor lobbyists.

Second, Congress should require that every appropriations committee hearing involving technology include a 15-minute "technical deep dive" where engineers explain the architecture, deployment pipeline. And testing strategy. This transparency would force agencies to come prepared with real technical plans, not glossy slide decks. It would also educate members over time, building a baseline of technical literacy that currently doesn't exist.

Third, lawmakers should embed a small number of software engineers from the US Digital Service and 18F into every congressional committee that oversees IT spending. These engineers would act as technical advisors, similar to how the Congressional Budget Office provides fiscal analysis. The cost would be trivial compared to the billions wasted annually. As the saying goes, an ounce of prevention is worth a pound of cure.

The Future of Government Tech Procurement

The long-term solution isn't just congressional action but a cultural shift in how the government views software. Software isn't a product to be bought; it's a capability to be cultivated. The most successful digital governments - like Estonia's - treat code as infrastructure, with continuous iteration and open standards. The United States would do well to study their model, which relies on small, empowered teams and a modular legal framework.

We are already seeing green shoots. The Department of Veterans Affairs has started using Rust for some performance-critical services. The Department of Defense is experimenting with DevSecOps pipelines. And a few agencies have adopted the 18F De-risking Guide. Which explicitly ties funding to technical milestones. But these are islands of excellence in a sea of inertia, and without congressional leadership, they will remain outliers

The Washington Post's coverage of Congress's lost grip on funding is a warning. But it's also an opportunity. As engineers, we have a responsibility to speak up - to testify. And to help design the systems that spend our tax dollars. If we can build distributed systems that handle billions of transactions per day, we can certainly build a government procurement system that works. The code is waiting.

Frequently Asked Questions

1. What does it mean that Congress has lost its grip on funding the government?
   It means Congress no longer effectively oversees how taxpayer money is spent, especially on complex technology projects, leading to rampant waste and failed IT systems.
2. Why are government technology projects so expensive and slow?
   They suffer from monolithic contracts, lack of technical oversight, waterfall requirements. And insufficient use of modern engineering practices like modular architecture and continuous delivery.
3. How can software engineering principles help Congress?
   By requiring modularity, real-time observability dashboards, and funding tied to delivery milestones, Congress can reintroduce accountability and efficiency.
4. What is the Office of Technology Assessment and why does it matter?
   The OTA was a nonpartisan office that provided Congress with technical analysis. Its reinstatement would equip lawmakers with the engineering expertise they currently lack.
5. Does open source software really save taxpayer money?
   Yes, because open source eliminates vendor lock-in, allows peer review. And enables modular contracting. It also reduces long-term maintenance costs,

What do you think

If you were consulting for Congress, what single technical standard would you mandate for all federal software projects?

Do you believe the US Digital Service should be scaled up into a permanent agency,? Or would that create another bureaucracy?

Is it possible to teach technical literacy to elected officials who have no engineering background,? Or should we instead rely on nonpartisan experts,