Why so many custom applications disappoint
Custom application development has a poor reputation with many executive committees. The dreaded scenario is well known: a voluminous specification, long months without seeing anything, late acceptance testing that reveals the need has changed, then a delivered application that nobody really knows how to evolve.
This scenario is not inevitable, and it is not down to the technology. It results from three decisions taken too early or never taken. The first concerns whether to build at all: something was developed that a solution on the market already did properly. The second concerns scope: the aim was to specify everything before delivering, on the strength of assumptions that only use could verify. The third concerns what comes next: nobody planned who would keep the application alive after the end of the project.
A custom application is an asset. It is decided like an investment, built like a product and maintained like a piece of equipment. That is the order in which we approach the subject.
Build or buy: the decision criteria
The question arises before any effort estimate. It is settled by functional scope, and not for an entire project: it is common for part of the need to call for a solution on the market and another part for development.
| Criterion | What argues for buying | What argues for building |
|---|---|---|
| Nature of the process | Standard, common to your industry | Specific to your organisation, a source of differentiation |
| Gap with the standard | Small: you accept adapting your practices | Large: specific configuration would be heavy |
| Pace of change | Stable, dictated by regulation or the market | Rapid, dictated by your own strategy |
| Integration | Few exchanges with the rest of the information system | At the heart of many flows and reference data sets |
| Internal capability | No team to maintain software | A lasting product team, or the will to build one |
| Total cost | Licences or subscription, integration, version upgrades | Building, operation, maintenance, obsolescence |
Two traps deserve to be pointed out. The first is the heavily adapted software package: it combines the cost of the licence, that of specific development and the difficulty of version upgrades. The second is the custom development of a commonplace function, which ties up developers on a subject where they will bring no advantage. Between the two, intermediate routes exist: a market solution supplemented by well-delimited extensions, a low-code platform for simple applications, an assembly of open source components.
Our approach to custom application development
Framing the product before the project. We start with the problem, not the solution: who the users are, what task they want to accomplish, how you will see that the application helps them. Framing isolates the high-risk assumptions (a journey never tested, data of uncertain quality, an interface with a legacy system) and defines a first version that puts them to the test.
Slicing into complete increments. Each increment cuts through all the layers: interface, business rules, data, exchanges with other applications. A thin but complete slice teaches more than an entire layer developed in isolation, because it can be deployed and used. Unfinished features remain hidden behind feature toggles, which makes it possible to deliver often without exposing work in progress.
Putting the foundation in place from the first increment. Continuous integration and deployment pipeline, automated tests, logging, monitoring: these elements are not finishing touches. Putting them in place from the outset makes each subsequent delivery inexpensive. When your organisation has an internal platform, we connect to it, in line with the practices described in our DevOps and platform engineering page.
Writing down structuring choices. Breakdown into modules, data model, integration mode: each decision that would be costly to undo is the subject of a short note indicating the context, the options rejected and the consequences accepted. These choices fit within the framework set by your IT architecture where one exists.
Preparing the handover. We work in a mixed team with your developers and your business owners. The transfer does not happen at the end of the engagement through a series of presentations: it happens through joint work, throughout development.
Maintainability: what is decided at design time
The longest part of an application’s life begins after go-live. Yet its ability to evolve is determined by the very first design choices, which are not very visible to the sponsor.
- Widely used technologies. A language and components that are widely used, supported and for which you will find skills. Technical originality comes at a price when recruiting.
- A modular structure. Modules with clear responsibilities, which can be modified and tested separately. This takes precedence over the sophistication of the architecture.
- Tests that act as a safety net. Without automated tests, every change becomes a gamble, and the team ends up no longer daring to touch the code. The page devoted to software quality and testing details how to organise them.
- Debt that is acknowledged. Shortcuts taken to meet a deadline are recorded, with their cost of resolution, in the team’s backlog. This is the condition for technical debt to remain a management choice and not a drift.
The mistakes we help you avoid
- Reproducing the old tool screen by screen. A like-for-like rebuild carries over the workarounds accumulated over the years. We start again from users’ tasks, not from existing screens.
- Confusing a demonstration with a production release. An increment shown in a meeting has proved nothing until it has been deployed and used on real data.
- Postponing non-functional requirements. Security, performance, data migration, operability: dealt with at the end of the project, they force you to rework foundations already laid.
- Underestimating integration. Exchanges with neighbouring applications and the migration of historical data account for a large share of the difficulties. Our consultants help your teams deal with them from the very first increments.
- Starting without a product owner. Without a person from the business who is available and empowered to decide on priorities, the development team decides in their place, or waits.
How to judge the result
Delivery on time is not enough to qualify success. From the framing stage, we agree with you on observable signs covering three areas.
On use: the share of target users who actually use the application, the features used and those that are not, the decline of parallel tools (spreadsheets, double entry) that the application was meant to eliminate.
On delivery: the frequency of production releases, the time between deciding on a change and making it available, the share of releases followed by an incident or a rollback.
On takeover: the time a new developer needs to deliver their first change, and your teams’ ability to evolve the application without us. This last criterion is the one that best shows whether the software was built to last.