Skip to main content
AI & Software

Custom Software Applications: What Happens After Delivery (Code, Maintenance and Evolution)

60% of a custom software application's true cost occurs after delivery. Practical guide on source code ownership, maintenance contracts and vendor lock-in.

Eduardo Fuentevilla Blanco

Written by Eduardo Fuentevilla Blanco

Robotics Engineer at Maedcore · Robotics Engineer LinkedIn ↗

November 16, 2026
Custom software applications after delivery — a delivered code package opening into a live architecture whose branches run out to maintenance, evolution, integrations and support, under the labels reliable, adaptable, secure and evolving
Custom software applications after delivery — a delivered code package opening into a live architecture whose branches run out to maintenance, evolution, integrations and support, under the labels reliable, adaptable, secure and evolving

Key Takeaways

  • ► 60% of a custom software application's total cost occurs during maintenance, not development. A €120,000 project generates €18,000–€48,000 per year in corrective maintenance alone.
  • ► Without an explicit IP assignment clause, source code belongs by default to the vendor, not the organisation that paid for the development, in any jurisdiction.
  • ► Owning the source code files is not the same as being able to operate them: without the repository, CI/CD pipeline, API keys and architecture documentation, the code is operationally inert.
  • ► A standard 'maintenance' contract almost always covers corrective work only; adaptive, preventive and perfective changes are invoiced separately at €1,500–€8,000 per change request.
  • ► The 5-gate framework (code sovereignty, operational independence, economics of change, support scope, exit cost) lets you quantify real lock-in exposure before signing or migrating.
  • ► In many markets, bespoke software development does not qualify for digitisation grant schemes that configurable platforms can access, widening the effective cost gap beyond headline prices.

The real investment in custom software doesn’t end when the vendor hands over the application: according to IEEE research, 60% of total software cost occurs during the maintenance phase, not during development. A €120,000 project can accumulate between €18,000 and €48,000 per year in maintenance, changes and technical debt. If the contract doesn’t explicitly address source code assignment, intellectual property belongs by default to the vendor, not to the organisation that paid for the development. This article starts where most others stop: the application is already in production, and it’s time to understand what you actually signed.


When Custom Software Becomes Genuinely Expensive

Maintenance is the primary expense of custom software, far from a marginal one. IEEE research shows that 60% of total software cost occurs during the maintenance phase, not during initial development.

The most widely cited industry benchmark puts annual maintenance at 15% to 25% of initial development cost for moderately complex applications. For business-critical systems, that figure rises to 25–40%. In concrete terms: a €200,000 project generates between €30,000 and €50,000 in annual maintenance cost alone. And that percentage grows with system age: Gartner documents a clear progression, with 10–25% in years 1–2, 15–30% in years 3–5, and 20–40% from year 6 onwards.

Hidden costs compound the picture. According to APIPilot, unforeseen costs add between 30% and 50% to total TCO in the first twelve months. In industrial MES projects, Shoplogix documents that five-year TCO is 2–3 times the initial licence cost, with hidden costs representing 60–70% of total investment.

And do projects even reach production on time and on budget? The Standish Group’s CHAOS report claims that only 29% of projects are completed on time and within budget, with average overruns of 89%. However, peer-reviewed academic analyses challenge that figure and place real overruns at 30–40%. The honest planning assumption: expect 30–40% cost overrun as a baseline; 89% is a tail risk, not the median.


What a Maintenance Contract Actually Covers (and What It Doesn’t)

A standard ‘maintenance’ contract almost always covers only corrective maintenance (fixing bugs within the original scope); adaptive, preventive and perfective work is invoiced separately as change requests.

The ISO/IEEE standard distinguishes four types of software maintenance:

Maintenance typeWhat it includesTypically in contract?Invoiced separately?
CorrectiveBug fixes within original scopeYesNo
AdaptiveNew features, integrations, process changesNoYes — at day rate
PreventiveDependency updates, proactive refactoringRarelyYes — if requested
PerfectivePerformance optimisation, UX improvementNoYes
Third-party security patchesSometimesFrequently, extra

The most common red flag: the contract uses the word ‘maintenance’ without specifying which type. If it isn’t detailed, assume it covers corrective only.

At senior rates in Western European markets (broadly €35 to €90 per hour), a medium-complexity change typically costs between €1,500 and €8,000, including analysis, development, testing and deployment. And that cost is not linear: NIST research shows that implementing a change after launch costs up to 100 times more than making it during design.

Many contracts also include clauses that give vendors discretion over transition support timelines. Pixeldust documents transition periods of just 30 days, wholly insufficient for complex systems, alongside ‘reasonable cooperation’ language that the vendor can interpret at their convenience.


In most jurisdictions, if the contract does not explicitly address intellectual property assignment, source code ownership defaults to the vendor, not the client who paid for the development.

In the Spanish context, Art&Iure Abogados notes that the Intellectual Property Act and Supreme Court case law attribute IP to the developer, while authorising the client to modify the code within the reasonable limits needed for correct operation. ‘Being allowed to modify’ is not the same as ‘owning’: without an explicit assignment, the client cannot sublicence it, transfer it to another vendor without restrictions, or exploit it commercially.

DiG Abogados puts it plainly: if source code delivery is not expressly agreed, the vendor may limit delivery to the compiled executable, which runs but cannot be modified or maintained by third parties.

Negotiating full assignment has a real cost: Progressive Robot estimates that a complete IP assignment adds 5% to 15% to development cost. Against the cost of a failed exit, it is one of the highest-return line items in the entire project.

A point almost no article in English covers adequately: the assignment must go beyond source code files. GetDevStudio notes that equally critical assets include repositories, servers, domains, third-party accounts, API keys, deployment pipelines and documentation. Without them, a source code assignment is a legal document with no operational value.


From ‘You Have the Code’ to ‘You Can Operate It’: The Gap Nobody Explains

Owning the source code .zip file is not the same as being able to deploy, maintain or transfer it to another vendor: without the repository, deployment pipeline, environment variables and architecture documentation, the code is operationally inert.

The cost of that gap is quantifiable. At market rates for senior engineers (€41–€90/hour), an undocumented subsystem requires an estimated 40 to 80 hours of reverse engineering before anyone can safely touch it. For a typical industrial application with five undocumented subsystems, the hidden onboarding cost ranges from €8,200 to €36,000 per new developer.

The risk is amplified by the ‘bus factor’: the number of people who would have to leave the project for it to fail. Pragmatic Coders documents that when that number is 1 or 2 (common in small development studios), the client loses access to the informal knowledge of how the system actually works the moment those people leave. The financial consequence is direct: 3Bird describes it precisely. When the vendor knows the client cannot exit easily, they have leverage over pricing, timelines and quality.


The Post-Delivery Dependency Audit: A 5-Gate Framework

Owning the code is not the same as running it — A 5-gate sequence: Code sovereignty, Operational independence, Economics of change, Support scope, Exit cost.

Before signing a new maintenance contract or deciding to migrate to a configurable platform, apply this five-gate framework to quantify your real exposure to technology lock-in. Each gate has a binary pass/fail criterion and a concrete cost implication.

This framework is built from the failure patterns documented in the reference research and from what we have seen happen in industrial software projects after delivery.


Gate 1: Code Sovereignty

Question: Does your organisation hold full, unconditional assignment of all intellectual property (including a third-party library inventory) in a repository you control?

CheckPassFail
IP assignment clause in the contract (assignment present, not a future promise)✓✗
Repository hosted under the client’s GitHub/GitLab organisation✓✗
Open-source licence inventory delivered✓✗
Escrow agreement in force (if no assignment)✓✗

Cost implication if it fails: You cannot put maintenance out to competitive tender. Negotiating assignment retroactively adds 5%–15% to the original development cost, or you budget for a full rebuild. Escrow is a last resort, not a substitute for assignment.


Gate 2: Operational Independence

Question: Can a competent developer who has never seen this code deploy, run and debug the application within 5 working days, using only the delivered documentation?

CheckPassFail
Architecture Decision Record (ADR) delivered✓✗
Deployment runbook with environment variables documented✓✗
API keys and third-party credentials held by the client✓✗
CI/CD pipeline access held by the client✓✗
Bus factor ≥ 3 (at least 3 people can explain the system)✓✗

Cost implication if it fails: Each undocumented subsystem adds an estimated 40–80 hours of reverse engineering at €41–€90/hour. For a typical industrial application with 5 undocumented subsystems: between €8,200 and €36,000 in hidden onboarding cost per new developer.


Gate 3: Economics of Change

Question: How much does it cost and how long does it take to make a typical change (adding a measurement parameter, integrating a new sensor, changing a report format)?

ScenarioConfigurable platformCustom application (typical)
New measurement typeParameter change, hoursDevelopment sprint, 2–5 days
New sensor integrationConnector configurationCustom API code, 1–3 weeks
New report formatTemplate editorDev + test + deployment cycle
Estimated cost€0–€500€1,500–€8,000
DependencyNoneOriginal vendor or new onboarding

Decision rule: If your process changes more than twice a year (common in R&D and quality inspection), the per-change cost differential alone justifies a configurable platform over an 18–24 month horizon. In an inspection project we built for a client in the nuclear sector, the requirement to add new radiation measurement types every time the protocol changed was the deciding factor in choosing a configurable architecture over hardcoded logic.


Gate 4: Actual Scope of the Support Contract

Question: What does your current support agreement actually cover?

Maintenance typeTypically included?Invoiced separately?
Corrective (bugs within original scope)YesNo
Adaptive (new features, integrations)NoYes — at day rate
Preventive (dependency updates)RarelyYes — if requested
Perfective (performance optimisation)NoYes
Third-party library security patchesSometimesFrequently, extra

Red flag: If the contract says ‘maintenance’ without specifying the type according to the ISO/IEEE classification, assume it covers corrective only. Everything else is a change request with its own quote.


Gate 5: Exit Cost

Question: If you decided to migrate to another solution today, what would it cost?

Exit componentEstimate
Data export and migration€2,000–€15,000 depending on data model complexity
Vendor transition assistance (if not contracted)€5,000–€25,000 at day rates
Parallel running period1–3 months of double cost
Staff retraining20–40 hours per user
Integration rebuild€5,000–€30,000 per integration

Decision rule: If total exit cost exceeds 50% of the original development cost, you are effectively captive. This calculation must be made during negotiation of the original contract, not afterwards.


Reading the Results

  • 5 gates passed: Healthy custom software investment. Maintenance is competitive and lock-in risk is low.
  • 3–4 gates passed: Manageable situation with targeted remediation, typically documentation and credential transfer.
  • 0–2 gates passed: The custom application is already worse than the standard tool it replaced. Exit cost is accumulating compound interest.

The Most Common Failure Modes (and How to Avoid Them)

The post-delivery economics of custom software fail in predictable ways.

The fixed-price contract. It looks safe for the client. In practice, it creates a zero-sum game: every hour the vendor spends beyond the estimate comes out of their margin. The result is lower-quality code (fewer tests, less documentation, architectural shortcuts) that costs more to maintain precisely when stability is most needed.

Invisible technical debt. Poorly documented code becomes a burden that no external developer wants to touch. Third-party libraries deprecate, external APIs change versions, operating systems evolve. In industrial contexts this includes OPC-UA library updates, sensor firmware changes and ERP API deprecations, none of which are typically covered in a standard maintenance contract.

The fixed-price illusion and government grant eligibility. In many markets, bespoke software development does not qualify for digitisation grant schemes, while configurable tools often do. In Spain, for example, the Kit Digital voucher (ranging from €2,000 for sole traders to €12,000 for companies with 50–249 employees) is not available for custom development, but may be available for configurable platforms. This makes the effective cost gap between the two options significantly larger than headline prices suggest.

Scope creep as a cost multiplier. Raftlabs documents that mid-project feature expansion without strict change control protocols is one of the primary causes of cost overrun, compounding both development cost and future regression testing overhead.

Frequently Asked Questions

Who owns the source code of a custom software application?

In most jurisdictions (and explicitly under Spanish law), if the contract does not expressly regulate intellectual property assignment, source code belongs by default to the vendor who developed it, not the client who paid for it. For ownership to transfer to the client, an explicit IP assignment clause must be included, one that also covers repositories, deployment pipelines, API keys and documentation, not just the code files themselves.

How much does annual maintenance of an industrial custom software application cost?

The most widely cited benchmark puts annual maintenance at 15%–25% of initial development cost for moderately complex applications, rising to 25–40% for critical systems. For a €120,000 industrial application, that means between €18,000 and €48,000 per year, and that figure covers only corrective maintenance. Adaptive changes are invoiced separately, typically at €1,500–€8,000 per request at senior market rates.

What is the 'bus factor' in industrial software and why does it matter?

The bus factor is the number of people who would have to leave the project for it to fail. In small development studios, that number is typically 1 or 2. If that person leaves, the client loses access to the informal knowledge of how the system actually works. Reconstructing that knowledge requires reverse engineering: an estimated 40–80 hours per undocumented subsystem at €41–€90/hour.

When does it make sense to migrate from a custom application to a configurable platform?

The clearest signal is when accumulated change request costs over the past 12 months exceed 20% of the original development cost, or when the process changes more than twice a year and each change requires a development sprint. Applying the 5-gate framework: if you pass fewer than 3 gates, the custom application is already costing more than a configurable alternative, even after counting the migration cost.

What assets must be transferred beyond the source code files themselves?

Source code files alone are operationally worthless without the full supporting stack. Equally critical assets include the version-control repository, CI/CD pipeline configuration, environment variables, API keys, third-party account credentials, server access and architecture documentation. All of these should be explicitly listed in the IP assignment clause of the contract.


Sources

  • Keyhole Software — Custom Software Development Cost: 2026 Pricing & Timeline Benchmarks — Keyhole Software, 2026
  • APIPilot — Total Cost of Ownership for Custom Software: The 2026 Strategic Guide — APIPilot, 2026
  • Shoplogix — Total Cost of Ownership for MES: Financial Guide for Smart Manufacturing — Shoplogix, 2025
  • EltexSoft — Software Project Cost Overruns: The Data — EltexSoft, citing Standish Group CHAOS Report, 2025
  • Academia.edu — The Standish Group Report: Does It Really Describe a Software Crisis? — Peer-reviewed analysis, 2006/cited 2024
  • Raftlabs — Custom Software Development Statistics 2026 — Raftlabs, citing Standish Group, NIST, McKinsey, 2026
  • Progressive Robot — Source Code Ownership: Essential Guide to Avoid IP Risk — Progressive Robot, 2026
  • DiG Abogados — Contrato de Desarrollo de Software: Cláusulas Esenciales — DiG Abogados, 2026
  • Art&Iure Abogados — Entrega del Código Fuente — Art&Iure Abogados, 2022
  • Pragmatic Coders — Vendor Lock-In in Custom Software Development — Pragmatic Coders, 2026
  • 3Bird — How Do You Avoid Vendor Dependency in IT Outsourcing? — 3Bird, 2026
  • Pixeldust — Vendor Dependency Risk: When Your Software Project Is Designed to Lock You In — Pixeldust, 2026
  • Savi Business Management — Software Maintenance Costs: Gartner Rule (2026) — Savi, citing Gartner and IEEE, 2026
  • Armadillo Amarillo — ¿Cuánto Cuesta Hacer un Software a Medida? — Armadillo Amarillo, 2025
  • GetDevStudio — Source Code Ownership in Outsourced Software Projects — GetDevStudio, 2026
#custom software #industrial software #software maintenance #software intellectual property #software TCO #vendor lock-in #industrial digitalisation

About the Author

Eduardo Fuentevilla Blanco

Robotics Engineer

For over a decade, I have been driven by a single mission: leveraging AI and robotics to build a world of automated production. I believe that by creating self-sufficient systems, we can empower people to refocus on what truly matters—their families and their passions. My expertise spans from winning prestigious European startup competitions to architecting complex, integrated hardware and software projects. I specialize in bridging the gap between today's industrial challenges and tomorrow's autonomous solutions.

AI & RoboticsIndustrial AutomationHardware & Software IntegrationIoT

Ready to transform your company?

Book a free 30-minute meeting with an engineer.