Picture a common situation: a webhook replay tool costs €50 a month from an established vendor. The purchase request goes into procurement, where a vendor security assessment and a slot on the architecture review board can push the calendar back by more than eight weeks.

Teams under sprint deadlines frequently skip that wait. An engineer uses Claude Code or Cursor to put together a replacement service in an afternoon. Finance sees a clean monthly ledger with no new SaaS subscriptions. That ledger has no line for the developer time spent building it, or for the maintenance bill that can pass €30,000 over the next three years.

When a coding agent can build a working tool before dinner, writing it in-house feels free. The cost just moves from writing the code to keeping it running.


Why Technical Teams Build Shadow Software

Take a team lead who files a purchase request for a simple €50 tool and receives a 40-page vendor risk questionnaire in return. That process guards recurring operational budgets (OPEX). But after waiting weeks for security reviews and administrative sign-offs, hacking together an internal workaround starts to look much easier than continuing the procurement dance.

Organizational Procurement Friction
8-week review, security questionnaires, legal review
↓
Visible to Finance
  • Avoided €50/mo SaaS subscription
  • Controlled operating expense
  • No external purchase orders
Invisible to Finance
  • Initial build payroll
  • Compounding Day-2 tax
  • Security blindspots
  • Incident downtime

Ronald Coase’s transaction cost theory applies directly to the sprint backlog. Once buying an outside tool takes more effort than building it internally, teams tend to build their own.

The accounting hides this. A subscription is a line item that needs a manager’s signature. Engineering salaries sit in the budget as fixed overhead. Having an engineer spend an afternoon with Claude Code triggers no budget review at all, even though someone now has to keep that new service alive.


The FinOps Arithmetic of “Free” Software

Start with what an engineer actually costs. Once salary and social contributions are added to hardware and overhead, a software engineer in a Western European tech hub costs €90 to €130 per hour (roughly €100 per hour on average).

1. Building It with Claude Code

An engineer using Claude Code can scaffold and test a working webhook service in roughly 12 hours:

Prompting & Integration Labor = 12 hours × €100/hour = €1,200
Model API & Compute Usage    = €50
Total Initial Build Cost     = €1,250

Spending €1,250 looks cheap next to two months of procurement forms. Writing the first version is only a small part of the total cost, though.

2. Keeping It Running

Software needs upkeep as the systems around it change. Industry standards such as ISO/IEC/IEEE 14764 and decades of systems research put most of a system’s cost after launch. Now that AI shrinks the initial build to a day or two, almost the entire cost sits in maintenance.

Total Cost of Ownership (TCO) Lifecycle Split

AI-Built Internal Tool
Initial Build: 5–10%
Ongoing Maintenance: 90–95%
Initial build phase (Claude Code scaffolding, €1,250)
Upgrades, deprecations, incident triage & infra shifts (€28,800)

Over three years, a small internal service usually eats up about 8 hours of attention a month:

About 2 hours a month go to dependency and security updates, like bumping Node.js versions or patching flagged packages. Another 2 hours go to API or database changes. Rotating expired keys or fixing a broken CI build adds 1.5 hours. The remaining 2.5 hours go to debugging why a cron job stalled at night or why a webhook stopped firing.

Total Ongoing Maintenance: ~8 hours/month (96 hours/year)
Annual Maintenance Payroll: 96 hours × €100/hour = €9,600 / year
Three-Year Maintenance Cost: €9,600 × 3 = €28,800

Adding maintenance to the initial build gives the three-year total cost of ownership:

TCO (Claude Code Shadow Service) = €1,250 (Build) + €28,800 (Maintenance) = €30,050
TCO (Commercial SaaS)            = €50/month × 36 months                  = €1,800

Even with Claude cutting the initial build to €1,250, the three-year cost lands at roughly €30,000, which is nearly seventeen times the vendor’s price.


Fast Scaffolding and Deferred Architecture

Building an internal tool with login and a database used to take weeks. That effort acted as a natural brake, and engineers thought twice before writing custom software for a minor annoyance.

Coding agents have removed that brake. When a developer can generate the database tables and API routes before the end of the day, teams build more custom tools. It is a textbook case of Jevons Paradox: making code cheaper to write increases the amount of custom software a company ends up maintaining.

The Day-2 Operational Iceberg

Prompt Synthesis • 10% Surface Application Logic

Application logic and API routes generated during initial prompting sessions.

Production Readiness Horizon
Deferred Operations • 90% Post-Deployment Maintenance
  • Observability and distributed tracing (OpenTelemetry)
  • Secret rotation, least-privilege IAM roles
  • Graceful shutdowns, health probes, connection pooling
  • Integration tests and CI regression suites
  • Base image scanning, SBOM upkeep
  • Runbooks and disaster recovery

Quick prompt iterations create a false milestone. A utility that passes local tests and runs in staging looks ready for production, so teams ship it.

Real software ownership starts after code reaches production, a point experienced site reliability engineers make often. Prompt-generated microservices skip many safeguards ownership needs. Credential rotation is a typical gap, and it leaves static API tokens sitting in container environment variables. Commercial tools ship with granular role-based access and audit logs. The internal script runs on a shared admin token, or on a private subnet with no authentication. Backoff logic and circuit breakers are usually missing too, so when an upstream dependency fails, the homegrown tool floods internal databases with unbounded retries and deepens the outage.

The engineers behind these tools usually act in good faith. Generated prototype code simply looks finished long before it is production-ready, and the gap shows up later as technical debt.


Anatomy of an 18-Month-Old Shadow Service

The cost of shadow tooling seldom shows up in the sprint where the code was written. It tends to surface about eighteen months later, during an incident.

Anatomy of an 18-Month-Old Shadow Service

Month 01
Fast Scaffolding

Engineer builds a webhook sync service using an AI coding tool. Deploys to an unmonitored node with a personal API token. No alerts configured beyond a shared Slack channel.

Month 08
Team Reorganization

The author moves to another team. Nobody touches the repository after that, and dependencies go stale on the running service.

Month 18
Upstream Deprecation & Outage

Upstream SaaS updates its API endpoints and drops older TLS ciphers. Shadow service fails silently; webhook retries back up. Memory exhaustion crashes shared worker nodes. On-call engineers spend 6 hours debugging undocumented code.

When the orphaned tool breaks, several problems hit at once. The repository has no architecture decision records (ADRs) and no regression tests, because the tool grew out of a chat conversation. The engineer who gets paged has to figure out what the code was supposed to do at 3 a.m.

Notifications make things worse. Homegrown tools frequently post noisy messages to shared channels, and teams end up muting them. A real failure can then go unnoticed.

The container itself is a third concern. An unmaintained tool usually runs as a static Docker image on an outdated base, with unpatched CVEs that become a quiet security liability inside the private network.

DORA research links strong engineering teams to low operational toil and stable deployments. Each unowned tool adds another thing that can break in production, pushing up both Mean Time to Restore (MTTR) and Change Failure Rate.


Practical Guardrails for Shadow Tooling

Preventing shadow software debt starts with matching procurement speed to delivery speed. Teams that limit architectural sprawl and standardize on common platforms have fewer orphaned services to look after.

Organizational Mitigation Strategy

Fast-Path Procurement
  • Discretionary spend (<€100/mo)
  • 48-hour compliance triage
Platform Foundations
  • Build on Retool / internal chassis
  • Centralized auth and logging
Ephemeral Service TTLs
  • Mandatory 90-day sunset dates
  • Automated decommission gates
FinOps Visibility
  • Attribute maintenance hours to teams
  • Expose true lifecycle payroll costs

1. Establish Fast-Path Micro-Procurement

Long review cycles create the incentive to build workarounds. Scaling review depth to financial and security risk removes much of it:

  • Discretionary allowances: team leads get credit card authority for low-cost operational tools (up to €100/month) that handle no personally identifiable information (PII).
  • Automated vendor tiering: a 48-hour automated intake replaces the multi-week review board for vendors holding a SOC 2 Type II or ISO/IEC 27001 certification.

2. Standardize on Internal Developer Platforms

Some workflows require custom software. In those cases, teams can build on a standardized internal platform or a low-code framework instead of starting from a blank repository.

Platforms such as Retool and Appsmith, or a well-maintained internal service template, handle identity management, role-based access control (RBAC), and security patching. Engineering effort then goes into business logic, as discussed in Why Low-Code is a Must-Have in Every Product Team’s Toolkit.

3. Put an Expiration Date on Quick AI Tools

Scripts built with AI assistants to get past a procurement blocker benefit from clear lifecycle rules. A 90-day time-to-live (TTL) works well: the experimental service gets an expiration date, and it shuts down automatically afterwards unless a team gives it a real owner and service-level objectives (SLOs). Listing internal tools in a catalog such as Backstage, with an owner and a repo link, keeps the inventory visible.

4. Quantify Maintenance in Sprint Planning

Track ongoing maintenance in sprint retrospectives so leadership can see the recurring payroll spent on internal tools. A homegrown script that costs €800 a month in senior engineering time makes a €50 commercial tool much easier to approve.


Once a purchase request takes longer than a sprint, some engineers will code around it.

With an AI assistant, that workaround takes an afternoon. Someone can have a custom webhook service running before dinner, even though keeping it alive over the next three years costs far more than the first draft of the code. Banning AI tools misses the cause. When buying a €50 tool takes days instead of months, teams rarely bother building a €30,000 replacement.