The real cost of a custom web development project

The cost of custom web development is not a price per square metre: it is the sum of decisions — scope, complexity, integrations, software architecture, security, team seniority — plus the costs you only see after go-live: maintenance, evolutions and technical debt. This guide gives Swiss-market orders of magnitude, the factors that really move the invoice, and a method for comparing custom software, off-the-shelf and low-code on the only number that matters: total cost of ownership (TCO).

In short: in Switzerland, a custom web application starts around CHF 25–40k for a first useful scope, sits between CHF 60–150k for a complete business application, and beyond for a multi-actor platform. Initial development, however, is only 40–60% of the five-year TCO: the rest is maintenance, evolutions and — if the architecture was botched — technical debt.

Key takeaways

• Five factors drive the price: scope, functional complexity, integrations, security requirements, team seniority.
• Compare 3–5 year TCO, never initial quotes: maintenance and technical debt make the real difference.
• Custom is not always the answer: ask the build vs buy question first.
• An abnormally low quote is a deferred cost: juniors billed as seniors, underestimated scope, sacrificed delivery quality.
• Technical ownership — code, repositories, CI/CD in your name — must be contractual from day one.

This guide is the cost chapter of our complete custom software development guide.

Table of contents

• What really moves the price
• The invisible costs: maintenance, debt, TCO
• Custom vs off-the-shelf vs low-code
• Timeline and budget
• Three typical budget examples
• Fixed price, capacity or day rate?
• The decision framework
• Classic pricing mistakes
• FAQ

What really moves the price

Scope. The first lever: every screen, user role and business rule adds days. A disciplined scope — an MVP that nails the primary use case — costs two to three times less than an exhaustive specification half of which will never be used.

Functional complexity. A well-designed CRUD is fast; a business calculation engine, a multi-actor workflow or real-time features are not. It is the complexity of the rules, not the number of pages, that drives cost — the core of what we build as business software.

Integrations. Connecting an ERP, a CRM or a payment system can cost more than the feature it serves: documentation quality, test environments, data reconciliation. Budget 2 to 15 days per integration depending on API maturity.

Software architecture. Over-engineering (microservices for 200 users) wastes money; under-engineering blocks scalability and is paid back as a rebuild. An architecture proportionate to the real need is the project's best investment: it determines maintainability, and therefore the cost of every future evolution.

Security. Robust authentication, role management, encryption, compliance (GDPR/nFADP): on an application handling customer data, security is 10–20% of the effort — and 100% of the risk if you skimp on it.

Seniority. A senior engineer costs more per day and less per project: fewer days, less rework, a healthier codebase. The day-rate gap pays itself back in delivery quality.

The invisible costs: maintenance, debt, TCO

The initial quote is the visible part. Over five years, a living application costs 15–25% of its initial development per year in maintenance: updated dependencies, security, small evolutions, support. That is not a defect — it is the price of a working software asset, and your teams' business continuity depends on it.

The real danger lies elsewhere: technical debt. A badly architected codebase turns every evolution into a worksite: what should take three days takes ten, then twenty. Our cost analysis shows untreated debt can double the cost of ownership within three years. That is why comparing two quotes without comparing architectures and practices (tests, reviews, CI/CD) is meaningless. Ask each supplier the same two questions: what does maintainability look like in year three, and who pays when it degrades? The answers reveal more than any line item.

Custom vs off-the-shelf vs low-code

Before pricing custom software development, check that it is justified — the subject of our build vs buy guide. In summary:

Simple rule: standard process → off-the-shelf; differentiating process → custom; simple internal automation → low-code may suffice. A product meant to be sold (SaaS) follows its own logic — see our SaaS products service.

Timeline and budget

The calendar is a cost factor in its own right. A serious custom web application MVP ships in 8–14 weeks; a complete business application in 4–8 months, in usable increments. Beware of compression promises: shortening the timeline by inflating the team raises coordination cost, and shortening it by skipping tests creates the debt that will blow next year's budget. A concrete example of a well-sliced scope: the Attanorm J-Learn business configurator, delivered in usable stages.

The decision framework

• The process is differentiating and durable → custom; TCO pays off once avoided licences and productivity gains exceed maintenance.
• The need is standard → off-the-shelf, accepting integration work — often the real hidden cost.
• The need is internal, simple and bounded → low-code, accepting the ceiling.
• The budget is tight → cut scope, never quality: a small healthy product beats a large indebted one.

Three typical budget examples

Business configurator (CHF 30–60k). A tool that turns a catalogue and calculation rules into a guided journey for sales teams or customers. The budget goes into the rules engine and the interface, very little into infrastructure. Classic trap: underestimating source data quality — cleaning the catalogue can cost as much as the development itself.

Complete business application (CHF 60–150k). Managing a core process — records, validation workflow, reporting, three to five user roles, one or two integrations (ERP, accounting). Here software architecture and data modelling weigh 25–30% of the effort, and it is money well placed: it is what keeps evolutions cheap for five years.

Multi-actor platform (CHF 150k and beyond). Several user types, billing, notifications, a public API, real scalability requirements. The budget shifts toward security, performance and operations. At this level, project governance (milestones, continuous acceptance, environments) becomes a line item of its own — skimping on it is paid back in business continuity incidents.

Fixed price, monthly capacity or bare day rate?

Fixed price locks the cost of a defined scope: reassuring for the budget, rigid on change — every evolution becomes a change order. It fits genuinely stable scopes. Monthly capacity bills the team month by month: flexible and transparent, but it assumes real internal steering. A bare day rate with no delivery accountability is the worst of both worlds if the supplier has no incentive to finish. In practice, healthy projects combine both: a first fixed-price lot to establish trust and the architecture, then monthly capacity for evolutions. Whatever the model, demand the same things: scope priced per lot, an explicit definition of done, and technical ownership in your name.

Classic pricing mistakes

• Comparing quotes without comparing scopes — demand pricing per functional lot, otherwise the lowest quote is simply the most incomplete one.
• Forgetting maintenance — budget 15–25% per year from the start, or TCO will catch up with you.
• Paying senior rates for junior work — ask who actually writes the code, and verify in review.
• Neglecting technical ownership — code, repositories and CI/CD must be in your name from the first commit.
• Pricing V1 as an end state — a living application is a stream of evolutions; the architecture must be designed for that.

FAQ

How much does a custom web application cost in Switzerland?

From CHF 25–40k for a first useful scope to CHF 60–150k for a complete business application; beyond that for multi-actor platforms. The useful number remains the 3–5 year TCO, maintenance included.

Why do quotes vary threefold?

Because they don't price the same thing: scope interpreted differently, real team seniority, tests and security included or not. Compare lot by lot, and ask what is not included.

Is low-code really cheaper?

At the start, yes. At scale, licences grow with usage and the functional ceiling ends up forcing costly workarounds. For a core business process, custom generally becomes cheaper again over 3–5 years.

How do you reduce cost without sacrificing quality?

Cut scope (strict MVP), not practices: tests, reviews and CI/CD are not options but the budget's life insurance. And ask build vs buy brick by brick — every standard component you buy is budget returned to what differentiates you.

Want a reliable figure rather than a range? Request a free diagnostic — a 48-hour estimate on your actual scope — or book a first call to frame the need.