Custom Software Development ROI: How to Calculate It (With a Worked Example)

TL;DR: ROI = (Total Benefits − Total Costs) ÷ Total Costs × 100. For custom software, “total benefits” must include revenue gained, costs avoided, and productivity recaptured — not just the obvious wins. “Total costs” must include build, maintenance, hosting, training, and opportunity cost — not just the invoice. Forrester TEI studies across enterprise deployments report an average 3-year ROI of 324% with an average payback period of 13–18 months (Forrester 2026). Automation-focused builds return investment in 6–12 months. The problem is not the formula — it is what most organisations leave out of the calculation on both sides.

Why Most ROI Conversations About Custom Software Are Wrong

Most ROI discussions around custom software fail in one of two directions:

Under-counting benefits: The business case includes only the most obvious return (replacing a SaaS subscription), missing the larger ROI drivers, staff hours recovered from workarounds, error reduction, faster decision-making from better data, and competitive advantage from capabilities competitors cannot buy.

Under-counting costs: The cost column includes only the build invoice, missing annual maintenance (15–20% of build cost), hosting, integration work, training, and the opportunity cost of the engineering team’s attention during the build.

Both errors produce unreliable decisions. Under-counted benefits undervalue the investment and cause under-investment. Under-counted costs overvalue returns and produce over-investment in the wrong projects.

This guide gives you the complete formula, the components that belong in each side, a worked example you can adapt, and the benchmarks to validate your result.

The ROI Formula: What Belongs on Each Side

Benefits (numerator)

Custom software benefits fall into four categories. The first two are measurable; the second two require defensible estimation:

Category 1: Revenue generated

Category 2: Costs avoided (most measurable)

Category 3: Productivity gains (quantify with time-motion data)

Custom software commonly delivers 15% operational efficiency gains on the workflows it serves (WeArearch 2026). For a team of 10 spending 40 hours/week on the automated workflow:

• Hours recovered per week: 10 × 40 × 15% = 60 hours
• Annual hours recovered: 60 × 52 = 3,120 hours
• Value at $75/hour fully-loaded cost: $234,000/year

Category 4: Strategic value (estimate conservatively)

• Time-to-market advantage from shipping features faster than competitors
• Data quality improvements enabling better decisions
• Competitive moat from capabilities competitors cannot subscribe to
• Regulatory compliance improvements reducing audit cost and breach risk

What to include vs exclude: Include Category 1 and 2 in full. Include Category 3 with time-motion data to support the estimate. Include Category 4 only with a conservative, explicit set of assumptions, never as a vague “strategic benefit” claim.

Costs (denominator)

One-time costs:

Recurring costs:

Often-missed cost items (NIST research, cited consistently through 2026):

• Opportunity cost of internal review time, product owner and stakeholder time during discovery, sprint reviews, and UAT
• Change request costs, requirement changes after development starts cost 6× during development, 15× after testing, 100× after release (NIST)
• Post-launch adoption overhead, change management, workflow redesign, process documentation updates

The Core ROI Equations

Year 1 ROI:

Year 1 ROI (%) = (Total Year 1 Benefits − Total Year 1 Costs) ÷ Total Year 1 Costs × 100

Multi-year undiscounted ROI:

3-Year ROI (%) = (Sum of Benefits Years 1–3 − Sum of Costs Years 1–3) ÷ Sum of Costs Years 1–3 × 100

Payback period:

Payback Period = Total Initial Investment ÷ Annual Net Benefit

Net Present Value (for formal business cases):
Apply a discount rate (typically 8–12% for technology investments) to future benefit streams. A positive NPV at your organisation’s hurdle rate means the investment creates value; negative NPV means it destroys it at that discount rate.

Worked Example: B2B Operations Portal

Scenario: A professional services firm with 60 staff is spending $90,000/year across three SaaS tools (CRM, project management, reporting), plus an estimated $45,000/year in staff time bridging the gaps between them with spreadsheets and manual re-keying. They commission a custom operations portal at a build cost of $140,000.

Costs (3-year model)

Benefits (3-year model)

Results

Sensitivity check: If the staff efficiency gain is half of the estimate (7.5% instead of 15%), the 3-year ROI falls to 73%, still strongly positive, payback at 16 months. If the build runs 20% over budget ($168,000), the 3-year ROI falls to 92%. The investment case holds across reasonable downside scenarios.

ROI Benchmarks: What Good Looks Like

The pattern: Automation-focused builds and SaaS replacement projects return investment fastest. Revenue-generating products have the highest ceiling but the widest variance. ERP replacements take longer to pay back but produce durable returns.

What “good ROI” looks like in practice:

• SBI Bank deployed a custom CRM platform → 400% lift in lead conversion, 90% reduction in loan-processing time (Mordor Intelligence 2026)
• PPG polymer plants deployed custom digital-twin applications → $400,000/month additional revenue (Mordor Intelligence 2026)
• UPS ORION routing optimisation (custom logistics algorithm) → $300–400M annual savings (Sumatosoft 2026)
• Harley-Davidson custom manufacturing system → 6-hour cycle from order to production start (down from 21 days) (Sumatosoft 2026)

What Kills Custom Software ROI: The 5 Most Expensive Mistakes

1. Requirements changes after development starts (the costliest single error)

Implementing a change during design costs 1×. During development: 6×. After testing: 15×. After release: 100× (NIST). A $5,000 requirement that arrives after go-live costs $500,000 to implement correctly. This is the primary reason the 3–4 week discovery phase is not overhead, it is cost insurance.

2. Building the wrong thing (scope misalignment)

40% of software projects fail to deliver on original objectives (Standish Group CHAOS 2024). The top cause: unclear requirements before development starts (39%). A project that ships on time and on budget but does not solve the original business problem has negative ROI regardless of what the budget spreadsheet says.

3. Measuring ROI too early

Most software ROI accrues in years 2 and 3, not year 1. Year 1 is the investment phase, build cost, training, adoption friction. The business case should model 3–5 years, not 12 months. CFOs who approve only projects with positive year-1 ROI systematically under-invest in software.

4. Not counting staff time as a benefit

The largest ROI driver in most workflow automation projects is staff hours recovered from manual processes, but it is also the most commonly omitted benefit because it requires time-motion data to defend. “We estimate 15% efficiency gain” without supporting data is not a business case. Conduct a time-motion audit before scoping: log what your team actually does, hour by hour, for two weeks. The data pays for itself in business case credibility.

5. Optimising for build cost instead of total value

Choosing the cheapest build quote is the most reliable way to destroy ROI. The median cost overrun for large IT projects is 45% (McKinsey). For projects over $15M, overruns exceed 66%. A $100K build that becomes $180K mid-project and ships 8 months late has worse ROI than a $140K project that ships on time, on scope, and produces the expected benefits from month one. Senior engineers, documented architecture, and structured discovery are not overhead on the cost side, they are ROI protection on the benefit side.

“Most organisations don’t fail because they picked the wrong technology. They fail because they didn’t define success before they started building.”

How InApps Structures Engagements for Measurable ROI

InApps treats ROI as a deliverable of the discovery phase, not a post-launch afterthought.

Before any code is written: Discovery produces a written business case with quantified benefits (revenue, cost avoidance, staff time recovered), total cost of ownership model (build, maintenance, hosting, training), and projected payback period. The client reviews and signs this before sprint one starts. If the numbers do not hold up, InApps will say so, including recommending SaaS when bespoke does not make financial sense.

During development: Every sprint produces working software against the agreed scope. Scope changes go through a formal change request with explicit ROI impact stated: “adding this feature adds $X to the build cost and delays payback by Y months.” The client decides with full information.

After go-live: InApps measures actual vs. projected ROI at 6 months and 12 months post-launch, efficiency gains, subscription costs eliminated, error rates before and after, and documents the results. This is how the 85%+ multi-year client retention happens: clients who can demonstrate ROI internally extend the engagement.

InApps has delivered 750+ projects across fintech (Techcombank, Prudential), enterprise retail (KFC, Lotte, MM Mega Market), and professional services across 15+ countries, all under ISO 27001:2022 certified security controls, with a 4.9/5 Clutch rating across 60+ verified reviews.

“We had a board presentation to justify the build. InApps produced the business case model in the discovery phase. The numbers were conservative enough that the board approved it on the first pass — and the actual 12-month outcome was 30% better than the projection.”

Build your ROI case with InApps →, discovery includes a quantified business case before any code is committed.

The ROI Calculation Checklist

Use this checklist before submitting any custom software business case:

Benefits side:

• Revenue generated, quantified with specific assumptions
• SaaS subscriptions eliminated, exact annual cost × contract years
• Staff workaround hours eliminated, time-motion data, not estimates
• Error correction costs, frequency × cost per error, before and after
• Integration middleware eliminated, exact annual cost
• Strategic value, stated with explicit assumptions, not vague claims
• Sensitivity analysis, what if the efficiency gain is 50% of your estimate?

Costs side:

• Build cost, full scope, not just development (design, QA, PM included)
• Infrastructure setup, cloud environment, CI/CD, security configuration
• Data migration, volume, data quality, legacy system complexity assessed
• Training and onboarding, user count × hours × cost
• Annual maintenance, 15–20% of build cost, explicitly stated
• Hosting, monthly cost at expected scale, modelled over 3 years
• Internal review time, product owner and stakeholder hours × cost
• Contingency, 15–20% buffer for scope changes (NIST cost-of-change data)

The business case:

• 3-year model (not 12 months)
• Payback period calculated
• Sensitivity analysis run on top 2 assumptions
• Year-by-year cash flow stated (investment phase vs. return phase clearly separated)
• Compared against status quo (keeping current SaaS + workarounds) over same period

Frequently Asked Questions

What is a good ROI for custom software?

Forrester TEI studies across enterprise deployments report an average 3-year ROI of 324% for custom software, with a payback period of 13–18 months. Automation-focused builds typically return investment in 6–12 months. A “good” ROI depends on your organisation’s hurdle rate and the project risk profile, but any 3-year ROI above 100% with a payback period under 24 months is generally considered a strong investment for non-revenue-generating software. Revenue-generating software should clear 300%+ to justify the development and market risk.

How do I calculate custom software ROI?

ROI = (Total Benefits − Total Costs) ÷ Total Costs × 100, measured over 3 years. Total benefits include: revenue generated, SaaS subscriptions eliminated, staff hours recovered from workarounds, error reduction, and middleware costs avoided. Total costs include: build cost, infrastructure setup, data migration, training, annual maintenance (15–20% of build), and hosting. The most common mistake is including only the build invoice in costs and only the SaaS subscription savings in benefits, both sides are significantly larger than this.

How long does custom software take to pay back?

The average payback period is 13–18 months for enterprise custom software (Forrester 2026). Automation-focused builds that replace large volumes of manual work pay back in 6–12 months. ERP and core system replacements take 18–36 months. Revenue-generating products vary widely based on market adoption. Year 1 is almost always an investment year, positive ROI typically begins in year 2 for most mid-market projects.

What is the biggest risk to custom software ROI?

Requirement changes after development begins. Implementing a change during design costs 1×; during development, 6×; after testing, 15×; after release, 100× (NIST). A $5,000 scope addition that arrives after go-live costs $500,000 to implement correctly. The structural protection is a 3–4 week discovery phase that captures and documents requirements before sprint one, with a formal change request process for any additions.

Should I include productivity gains in a custom software ROI case?

Yes, but only with supporting data. Productivity gains are the largest ROI driver in most workflow automation projects and the most commonly omitted benefit because they require time-motion data to defend. Conduct a structured time audit (what does your team actually do, hour by hour, for two weeks?) before building the business case. Custom software commonly delivers 15% operational efficiency gains on the workflows it serves (WeArearch 2026), but “commonly” is not the same as “guaranteed for your specific process.”

Is custom software worth it compared to SaaS from an ROI perspective?

For 50+ users on a core workflow, custom software is typically worth it on a 3–5 year TCO basis. For a 50-user team on a $200/user/month SaaS platform, the 5-year SaaS cost is approximately $762,000 vs. $145,000 for a comparable bespoke build with maintenance, a $617,000 saving. For fewer than 20 users on a non-core function, SaaS almost always wins on ROI because the build cost cannot be amortised across enough user-years. The decision is function-by-function, not organisation-wide. See: Bespoke Software vs SaaS.

Key Takeaways

• ROI formula: (Total Benefits − Total Costs) ÷ Total Costs × 100, measured over 3 years minimum.
• Forrester TEI benchmark: Average 3-year ROI of 324%, payback 13–18 months for enterprise custom software.
• Automation builds return investment in 6–12 months, the fastest custom software ROI category.
• Four benefit categories: Revenue generated, costs avoided, productivity gains (with time-motion data), strategic value (conservative estimates only).
• Full cost model: Build + infrastructure setup + data migration + training + 15–20%/yr maintenance + hosting. Not just the invoice.
• Biggest ROI killer: Requirement changes after development starts. NIST cost multipliers: 1× (design), 6× (development), 15× (testing), 100× (post-release).
• 40% of projects fail to deliver on original objectives (Standish CHAOS 2024). The cause is almost never technology, it is undefined requirements and absent scope discipline.
• Real-world examples: SBI Bank +400% lead conversion; PPG +$400K/month revenue; Harley-Davidson 21 days → 6 hours order-to-production.