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

For decades, the central tension in American governance has been who decides how taxpayer dollars are spent. That tension has reached a breaking point. According to The Washington Post, "Congress has lost its grip on funding the government. " The assertion isn't hyperbolic - it reflects a steady erosion of the legislative branch's constitutional "power of the purse. " But this isn't just a story about politics or budget procedures. It is, at its core, a story about software, systems. And the failure of technical governance.

The US government runs on code that nobody audits - here's why that's a constitutional crisis. Every year, the federal government spends over $100 billion on information technology. Yet the mechanisms Congress uses to approve, track, and oversee that spending are stuck in a pre-digital era. When the legislative branch can't understand the systems it funds, it can't meaningfully control them. The result is that executive agencies, not Congress, increasingly determine how money flows to software projects, cloud contracts. And data infrastructure. This isn't partisanship; it's a structural failure that engineers recognize all too well.

This article isn't a rehash of political headlines it's an engineer's analysis of why Congress has lost its grip, how technical debt in government software amplifies that loss. And what software developers can learn from watching the world's largest IT spender run aground on its own legacy code.

How Outdated IT Procurement Erodes Congressional Authority

The Federal Acquisition Regulation (FAR) is nearly 2,000 pages long. It governs how the government buys everything from paper clips to cloud infrastructure. But when Congress passes appropriations bills, it rarely specifies how those funds should be spent on software development. Instead, agencies receive broad buckets of money and then interpret the intent through their own procurement offices. This creates a principal-agent problem: Congress intends one outcome, but the executive branch's technical decisions produce another.

For example, the Department of Veterans Affairs spent over a decade and billions of dollars on an electronic health records system that never worked as intended. Congress appropriated funds for a "modernization," but the agency's procurement processes locked it into a decades-old contract that prioritized vendor lock-in over performance. The Government Accountability Office (GAO) has repeatedly flagged "weak IT oversight" as a high-risk issue since 2003. By the time Congress holds hearings on a failed project, the money is already spent - and the software is already broken.

The Trump Administration and the Rewriting of Budget Rules

During the Trump administration, executive orders and Office of Management and Budget (OMB) memoranda shifted significant spending authority from Congress to the White House. For instance, the use of "reprogramming" and "transfer authority" allowed agencies to move money between accounts without prior congressional approval. This is the software equivalent of granting root access to a single user without audit logs. In production environments, we call that an incident waiting to happen - yet it became standard practice for billions of dollars.

NBC News reported that "as Trump has usurped power, a weak Congress has diminished its own relevance. " From an engineering standpoint, that's like saying the system administrator disabled all authorization checks. Without proper checks and balances, any organization - government or startup - will see its oversight mechanisms decay. Congress lacks the technical staff to read OMB circulars and understand when a funding shift amounts to a policy change, rather than a routine budget adjustment.

The result is a funding ecosystem where the executive branch controls not just the distribution of money. But the very definition of what the money is supposed to build. When agencies say they need more funding for "cybersecurity modernization" or "AI readiness," Congress can't independently verify those claims because it doesn't maintain its own evaluation teams for IT projects. It relies entirely on the agencies' self-assessments, which are often optimistic to the point of fiction.

Why Congress Lacks Technical Expertise to Oversee Funding

The Government Accountability Office employs around 3,000 people. But only a fraction are trained software engineers or data scientists. The Congressional Budget Office (CBO) focuses on macroeconomics and doesn't systematically analyze software cost overruns. Meanwhile, the private sector spends billions on project management tools, testing frameworks. And CI/CD pipelines to keep budgets under control. Congress operates with spreadsheets and phone calls.

In 2020, the Washington Post highlighted the failure of the Census Bureau's software system. Which required emergency reprogramming after Congress had already approved $15 billion for the decennial count. The bureau's own Inspector General found that "the system wasn't developed in accordance with federal acquisition requirements. " Congress had no way to see that coming because it didn't audit the software - it only audited the contracts. Tools like static analysis - dependency tracking. And automated cost estimation are standard in any competent engineering firm. They are virtually absent in the legislative branch's oversight toolkit,

This isn't a partisan critiqueBoth parties have failed to fund a dedicated technology assessment office or to require that major IT projects submit to independent, software-level audits. The Office of Technology Assessment was defunded in 1995; despite multiple attempts, it has never been revived. That leaves Congress flying blind on the single largest category of discretionary spending.

Project Management Lessons from Government IT Failures

Consider the US Digital Service (USDS). Created after the disastrous Healthcare gov launch, it was supposed to bring modern engineering practices into government. But USDS operates as a special unit under the Executive Office of the President, not under Congress. Its existence partially compensates for the legislature's lack of technical talent. Yet USDS can't audit Congress's funding decisions; it can only help agencies build better software with the money they already have.

From a project management perspective, the government's approach resembles "waterfall on steroids. " Requirements are defined years before deployment, validation is performed by compliance officers who don't test the code. And "go-live" dates are set by statute rather than by engineering milestones. The GAO has identified four key causes of cost overruns in federal IT: incomplete requirements - insufficient testing, unrealistic schedule estimates. And lack of technical oversight. Every single one of these is a symptom of a funding process disconnected from delivery reality.

Engineers know that any project with a fixed budget but flexible scope is inherently risky. But Congress appropriates money with fixed amounts and expects agencies to deliver fixed scopes. When the scope changes (as it always does in software), there's no mechanism to recalibrate either the funding or the requirements without a new law. That creates an environment where agencies either hide problems or spend money on features nobody wants, just to fulfill a contractual line item.

The Rise of Algorithmic Governance and Unchecked Spending

As artificial intelligence and algorithmic decision-making enter government operations, the funding oversight problem becomes even more acute. When an agency purchases a machine learning model to determine eligibility for benefits, Congress may approve a line item for "AI pilot" without knowing the training data, the bias mitigation strategy or the cost of maintaining the model. The algorithm itself becomes a black box - not because of proprietary secrecy. But because the funding process never required visibility.

Forbes' analysis of this trend notes that "Congress is losing its grip on the nation's purse strings" partly because the scale and complexity of government spending have outstripped its analytical capacity. In software terms, this is the difference between a simple monolith and a sprawling microservices architecture. Congress was designed to oversee a monolith; we now have distributed, API-driven, cloud-hosted government services that change daily. Without an observability platform for the budget, Congress can't even see which services are consuming resources.

The solution isn't to ban technology - it's to build a congressional equivalent of monitoring and alerting. For example, a dashboard that tracks actual vs. planned spending across major IT projects, updated weekly, with automated flags for deviations beyond 10%. Such a system would require Congress to hire data engineers, not just budget analysts. It would also require agencies to expose cost data via APIs rather than PDF reports that's a technical change, not a political one.

What Software Engineers Can Learn from the Budget Crisis

There is a direct parallel between Congress's loss of budgetary control and a startup that grows too fast without technical debt management. In both cases, the decision-makers stop understanding the systems they fund. The symptoms are identical: escalating costs, missed deadlines, and a growing gap between what leadership approves and what engineering delivers.

Engineers working in large organizations can draw specific lessons. First, always maintain a clear traceability matrix between funding decisions and feature implementations. If your product roadmap says "improve login security," but the budget line item says "infrastructure upgrade," someone needs to connect those dots - or risk spending money on the wrong thing. Congress lacks that traceability; your organization doesn't have to.

Second, demand that any spending approval includes a technical review. In government, the Appropriations Committee authorizes money without ever seeing a line of code. In a tech company, no product manager would approve a $10 million contract without a tech lead's sign-off. The principle scales: funding decisions should always be coupled with engineering evaluations. If your company's C-suite approves budgets without ever talking to the development team, you have the same problem as Congress.

Finally, invest in observability - not just of your software. But of your budget. Track spending-per-feature, cost-per-deployment, and the lifetime cost of keeping legacy systems alive. The GAO estimates that the government spends over 80% of its IT budget on operations and maintenance, leaving only 20% for new development. That ratio is a direct consequence of invisible technical debt. Every engineering team that monitors its AWS bill and deploys automated cost controls is already ahead of the US Congress.

A Call for Technical Staff in Congressional Oversight

The most straightforward fix is to create a Congressional Technology Office that mirrors the Government Accountability Office but focuses exclusively on software, data, and AI systems. It would be responsible for independently verifying cost and schedule estimates for all major IT projects. It would conduct code-quality audits and maintain a public dashboard of project health. And it would have the authority to pause funding if technical milestones aren't met.

Several bills have been proposed, including the PIVOT Act (Promoting Innovation and Opportunities for Technology) that would create a centralized tech modernization fund. But such efforts remain stalled, partly because members of Congress fear that giving technical staff power would reduce their own control. This is a misunderstanding: delegating technical due diligence doesn't diminish oversight - it strengthens it. A committee chair who can say "our engineers validated that estimate" is far more powerful than one who must rely on the agency's word.

Until Congress hires its own CTO, data architect. And a unit of software auditors, the trend reported by the Washington Post will only accelerate. Every new cloud contract, every AI pilot, every modernization initiative will further entrench the executive branch's control over what the government actually builds with its money.

Frequently Asked Questions

1. What does "power of the purse" mean With Congress and IT?

It refers to Congress's constitutional authority to determine how federal funds are spent. In practice, this means committees approve budget amounts for agencies. But the details of what gets built - especially software - are left to executive branch interpretation.

2. How do government IT failures relate to Congress losing its grip on funding?

Because Congress can't independently evaluate the technical feasibility or cost accuracy of major IT projects, it approves funding based on agency promises rather than verified engineering data. This allows the executive branch to redirect funds and redefine project scope without legislative consent.

3. What tools could Congress use to regain oversight?

Congress needs its own version of Jira, Confluence. And a cost-tracking dashboard - but for procurement and appropriations. Common tools include automated cost estimating (COCOMO-like models), static analysis for contract compliance, and real-time spending APIs.

4. Is the problem political or technical?

It is both. The political will to retain the power of the purse exists in theory. But the technical capacity to exercise it does not. Without engineers on staff, Congress can't ask the right questions, let alone evaluate the answers.

5, and can software engineers influence government funding oversight

Yes. Engineers can volunteer for the US Digital Service, apply for fellowships with congressional committees. Or write to their representatives advocating for a Congressional Technology Office. Open-source contributions to government transparency projects also help.

Conclusion: Reclaiming Control Through Technical Literacy

The Washington Post's headline - "Congress has lost its grip on funding the government" - isn't merely a political observation it's an engineering crisis. When the branch of government that controls the budget can't understand the systems it pays for, the result is waste, inefficiency, and a gradual shift of power to those who do understand the code. The fix isn't a new political strategy; it's a new technical capability. Congress must hire engineers, build dashboards. And demand API-level transparency from every agency that spends federal dollars on technology.

For the software community, this is a call to action. We can build the tools that make government spending auditable. We can push our elected officials to treat software procurement as a first-class oversight activity. And we can apply the same project management disciplines we use in our startups and enterprises to the largest IT portfolio on Earth. The alternative is to watch the grip slip further - and with it, the very principle of democratic accountability.

What do you think?

If Congress created a dedicated Office of Technology Assessment tomorrow, what should its first audit target be - the Census IT system, the VA health records,? Or something else?

Should the US Digital Service be moved from the Executive Office to the Legislative Branch to give Congress its own technical muscle?

Can open-source principles like continuous delivery and automated testing ever be applied to the federal budget process, or will politics always trump engineering logic?