There’s a version of the American government IT contract that almost never gets discussed in public, because it isn’t a scandal in the legal sense — nobody breaks a law. It’s just how the machine runs. And the machine is built to reward complexity, not results.

The Chain, Not the Contract

A federal or state agency needs an IT worker. That need travels through a chain: agency → prime contractor → subcontractor → staffing vendor → sometimes a second staffing vendor reselling the requisition → the actual person who does the work. Every link in that chain takes a cut of the hourly rate before a single line of code gets written or a single ticket gets closed.

Older professionals in dark suits around a boardroom table, one standing with a folder while the others sit with documents and coffee in front of them
The room where the requisition is priced. The person who will do the work is not in it.

This isn’t a conspiracy. It’s the predictable output of two forces colliding:

  • Procurement law was built for a different era. Federal contracting rules (and the fifty separate state equivalents) were designed around competitive bidding for large, well-defined projects — not the fast-moving, skills-specific hiring that modern IT actually needs. So agencies default to generic “staff augmentation” contracts, because that’s the vehicle the rulebook makes easy, not because it’s the vehicle that makes sense.
  • Direct hiring is slower than the private sector agencies are competing against. A GS or state civil-service hire can take months and comes with salary caps that don’t match private-sector IT pay. Contracting lets an agency get a body in a seat in weeks, at market rate, without touching headcount rules. So contracting becomes the default, and the middlemen who service that default multiply.

Once that default is set, everyone downstream of it has an incentive to keep it exactly as complicated as it is. A five-layer subcontracting chain isn’t a bug for the vendors inside it — it’s the business model.

The Flywheel

Here’s the self-reinforcing loop:

  1. Procurement rules make direct hiring slow and contracting fast.
  2. Contracting flows through Vendor Management Systems (VMS platforms like Fieldglass or Beeline) that pre-approve dozens or hundreds of staffing vendors onto the same requisition.
  3. Any approved vendor can bid on any open req, so the same job gets shopped to ten, fifteen, twenty firms — which is why an IT worker with a decade of experience can get four calls in a week about the identical position.
  4. Because there are so many vendors chasing so few requisitions, none of them can compete on much besides speed and rate — not on quality of vetting, not on long-term retention, not on actually solving the agency’s problem.
  5. Agencies, buried in noise from vendor spam, start relying on the primes they already know, which further entrenches the incumbents rather than opening the field to whoever could do the best job.
  6. Because nothing about this loop produces better outcomes, agencies get less for their money — and the response to “the process isn’t working” is usually more process: more approval steps, more compliance paperwork, more audit requirements. Which makes direct hiring even slower. Which pushes agencies further toward step 1.
The procurement flywheelSix stages arranged in a clockwise loop: procurement rules make direct hiring slow and contracting fast; requisitions enter a vendor management system that pre-approves dozens of staffing firms; one job is shopped to twenty of them; none can compete on anything but speed and rate; agencies retreat to the primes they already know; outcomes get worse and the response is more process, which feeds back into stage one.Optimized for defensibility,not for resultsevery link is rational; the loop is not1Rules make hiring slowand contracting fast2Reqs enter a VMSdozens of vendors pre-approved3One job, twenty firmsfour calls in a single week4Nobody competes on qualityonly on speed and rate5Agencies retreat to the primesincumbents entrench6Outcomes get worseso the answer is more process
The loop, drawn. Stage six is the one that closes it: the remedy for a process that isn’t working is more process, which returns you to stage one with the wheel turning faster.

The flywheel doesn’t spin because anyone wants bad outcomes. It spins because at every individual link, the rational move is to work within the existing system rather than fight it — and the system was never actually optimized for the taxpayer or the worker. It was optimized for auditability and risk avoidance, which are not the same thing as effectiveness.

What Gets Lost

Three things fall out of this setup, quietly, year after year:

A desk seen from above: a printed sheet of rate and trend charts beside an open notebook, a hand writing on it and another at a laptop keyboard
Between the bill rate and the pay rate sits the chain itself. It is the one line item nobody publishes.

Money. A contractor billed to the government at $150 an hour might see $70–90 of that reach the person doing the work, after prime overhead and one or more staffing markups. The rest pays for the chain itself, not the output.

Accountability. When something goes wrong — a state Medicaid system audit finds improper subcontracting, or a “US-based only” contract turns out to include offshore delivery — the layering makes it genuinely hard to trace who was responsible. Diffused responsibility is, for the firms inside the chain, a feature.

Talent retention. American IT workers who’ve spent a decade building real expertise increasingly find themselves competing not on skill, but on which staffing vendor can shave the most off the bill rate. That’s a race that experienced domestic talent is structurally positioned to lose, not because they’re less capable, but because the system isn’t scoring for capability in the first place.

The Alternative Nobody Funds

None of this is unfixable. Every piece of it is a policy choice:

  • Procurement reform that lets agencies hire directly, at competitive pay, without a multi-month civil-service process.
  • Hard caps on subcontracting depth, so a contract can have one or two layers, not five.
  • Public disclosure requirements for the full vendor chain on any government IT contract, so “who’s actually doing this work, and for how much” is a matter of public record, not a trade secret.
  • Wage floor enforcement on visa-sponsored roles tied to government work, so cost arbitrage on labor isn’t quietly built into the system’s incentive structure.
The dome of the United States Capitol rising into a flat grey overcast sky, seen straight on and stripped of colour
Every item on the list has been introduced somewhere. None of them has a constituency the size of the one defending the status quo.

These are not radical ideas. Versions of them show up in insourcing pushes and procurement-reform bills at both the federal and state level, periodically, whenever public attention turns to government IT spending. They tend to lose momentum for the same reason the flywheel exists in the first place: the people best positioned to lobby for the status quo are the ones profiting from it, and the people paying the cost — taxpayers, and workers being quietly undercut — are diffuse and rarely organized.

The uncomfortable truth is that America’s government IT problem was never really about who is doing the work. It’s about a system that stopped asking whether the process produces good outcomes, and started only asking whether the process is defensible on paper. Red tape became the product. Everything downstream of that — the vendor spam, the wage compression, the five-layer subcontracting chains — is just what a system optimized for defensibility instead of results looks like when you’re standing inside it.