Custom software is software designed for a specific set of users, functions or organisational needs, rather than a general-purpose package sold to many businesses. A custom solution doesn't have to replace everything: it can be a focused application or an extension that works alongside your existing systems. It is worth considering when a verified requirement can't be met suitably by an existing product or its configuration.
This guide is for owners and operations leads who know work is falling between their tools but can't yet say what should be built. It shows how to turn one workflow gap into a small scope with requirements you can test. If your problem is a broken device, a network issue or a security concern, start with which kind of IT help owns the problem instead.
What makes a software solution custom?
IBM's overview of software development distinguishes software tailored to particular needs from packaged products intended for a wider market. Its description of development includes ongoing maintenance as well as creating and deploying the software. Custom software isn't finished when the first screen works.
In practice, three kinds of work overlap:
Three possible boundaries for a solution
- Configure a featureUse a rule, form or permission your existing software already supports.Evidence: the application owner shows it working on a real case.Pause if: it can't express the actual rule.
- Connect existing systemsLet systems you already use exchange supported records to reduce re-keying.Evidence: supported interfaces, approved access and a clear source of truth.Pause if: the interfaces don't support the handoff.
- Build a missing workflowCreate a small application or extension for a status, decision or handoff no tool manages.Evidence: named users, missing behaviour, exceptions, acceptance checks and an owner.Pause if: the rule is disputed or nobody will run it.
A solution can combine these approaches. Choose the smallest adequate scope, not the most impressive one.
A few things custom does not automatically mean:
- AI. A workflow gap may concern rules, records or decisions. AI is a possible component, not a requirement.
- A unique technology stack. Custom software can use existing components; assess their support and licensing.
- Owning everything. Ownership of code, licences, source access and data export is agreed in writing; it isn't automatic.
- No subscriptions or no maintenance. Hosting, third-party services and support still have to be arranged and paid for.
Start with the workflow gap, not a feature list
A feature list describes a solution someone has already imagined. A workflow gap describes what actually happens. Write down four things: what starts the work, who takes part, which records they use, and where the work stops or gets lost. Keep what you observed separate from the fix you suspect.
Which part needs configuration, integration or new software?
Work through each part of the gap separately. The answer for one part can be "configure", for another "integrate", and for a third "build", or "fix the process first".
| Observed gap | Route to investigate | Evidence before choosing | Stop or reconsider when |
|---|---|---|---|
| The existing application has the needed rule, but nobody uses it | Configure the existing feature | The application owner confirms the function, permissions and limits, and shows it working on a representative case | The feature can't express the real approval rule, or it exposes the wrong records |
| The correct records exist in two systems, but staff re-enter them | Integrate through supported interfaces | Which record is authoritative, stable identifiers, approved access and the operations each system actually supports | The interfaces or permissions don't support the handoff you need. Don't assume a connector exists |
| Several tools hold pieces, but none manages the agreed status and decision | A small custom workflow application or extension | Named users, the specific missing behaviour, the exception path, acceptance checks and an operating owner | The rule is still disputed, the benefit is unsupported, or nobody will own it in operation |
| People disagree about who approves a change | Clarify the process before any software | The business owner defines authority and escalation | New software would only encode a disputed rule |
Integration is a concept, not a promise. AWS describes application integration as getting independently built software systems to work together without manual intervention, but whether two particular systems can do that depends on their interfaces, permissions and limits. If records move between systems, plan and validate the data integration as its own piece of work.
Turn the gap into requirements you can test
A useful requirement says who needs something, what they need and why. The UK Government Digital Service's guidance on writing user stories (published 2016, last updated May 2016) frames this as the actor, the narrative and the goal, and describes acceptance criteria as outcomes you use as a checklist to confirm a user need is met. It is UK public-sector guidance, not a legal standard elsewhere, but the technique travels well.
Keep two kinds of requirement apart. Behaviour is what the software does: route, record, refuse, show. Constraints are the conditions it works under: who may access what, how long records are kept, how quickly it must respond, how it recovers. Constraint targets have to come from the business and technical owners. Don't invent generic numbers for them.
Here is the hypothetical service-change request as a scope card.
- Outcome
- A service-change request has a traceable decision before delivery is authorised.
- Users
- Account handler submits. An authorised service manager approves or rejects. The delivery coordinator acknowledges. A support owner handles technical exceptions.
- Inputs
- Request reference, existing customer reference, current service reference, proposed change and version. Synthetic examples only.
- Authority
- The existing customer system owns customer identity. The new workflow owns request status and approval evidence. The delivery system owns whether work is actually done; a sent message doesn't mean it is.
- First slice
- Submission, validation, decision history, approved handoff, acknowledgement and a visible exception queue.
- Excluded
- Billing, payment collection, automatic pricing, autonomous commercial decisions, a replacement CRM, AI classification and historic-data migration, unless separately scoped.
- Still unknown
- Real interface availability, access roles, record retention, expected workload, recovery tolerances, notification method and support coverage. Each needs a named owner and an agreed answer, not an invented default.
Each critical requirement then gets an observable check. The IDs below are invented test records.
| Requirement | Observable acceptance check | Owner and evidence |
|---|---|---|
| R1: incomplete changes stay out of approval | Submit test request CR-A without a service reference. It stays in Needs information, and no approval or handoff is created | The account handler checks the displayed state and the stored record |
| R2: only an authorised manager decides | The account handler tries to approve: the action is refused and the state doesn't change. A manager can approve a valid version | The business owner defines authority. The tester checks both roles on the server side, not just that a button is hidden |
| R3: changed terms need a new decision | Approve version 1, then change the proposed work to version 2. The version 1 approval must not authorise version 2 | The service manager checks versions and the decision history |
| R4: rejected or pending requests never reach delivery as approved | Reject CR-B and leave CR-C pending. Neither appears in the approved handoff | The delivery coordinator reconciles decision records against handoff records |
| R5: an uncertain handoff is reconciled before any replay | Simulate the destination accepting CR-D while the acknowledgement is lost. Reconcile by stable reference before replaying; no second delivery task appears | The implementer and support owner design duplicate control and test the real destination's behaviour |
| R6: acknowledgement is not work completion | Delivery acknowledges CR-D. The request shows Accepted for delivery, not Work completed | The delivery coordinator checks the actual operational state |
| R7: unresolved failures stay visible | Fail a handoff and exhaust the agreed safe recovery path. The request stays in the exception queue with a named owner | The support owner confirms the alert or queue and the manual reconciliation steps |
This table is a proposed specification, not a set of passed tests. Two details matter more than they look. R2 checks that a refused action is refused by the system, not merely hidden from the screen. R5 uses a stable reference to reconcile before replaying, because a reference makes duplicates easier to detect but doesn't guarantee each request is processed exactly once.
Worked scope: an approved change reaches delivery once
The first slice follows one request from submission to delivery's acknowledgement, with proposed handling for the known failure cases below. Further cases may emerge during discovery and testing.
Request states and who decides
- ReceivedAccount handler submits
- Ready for reviewRequired details are present
- ApprovedAuthorised service manager decides
- Handoff pendingSent to delivery by stable reference
- Accepted for deliveryDelivery coordinator acknowledges
- Missing details → Needs information, back to the account handler
- Rejected → closed with the reason recorded; nothing goes to delivery
- Terms changed → new version, back to Ready for review
- Handoff uncertain → support owner reconciles with delivery before any replay
"Accepted for delivery" is not "work completed". The delivery system still owns whether the work is done.
Why reconcile before replaying? Microsoft's Retry pattern guidance notes that if an operation isn't idempotent, a retry can run it more than once: a service might process a request successfully but fail to send the response, and the retry sends it again. The same guidance says retry code should be tested against a range of failure conditions. That is the risk R5 is designed around; it isn't a recipe or a guarantee.
| Exception | Owner | What happens |
|---|---|---|
| Missing input | Account handler | The request stays in Needs information until it's complete |
| Disputed commercial change | Service manager | The manager decides; software doesn't decide feasibility or price |
| Stale version | Service manager | The new version needs a new approval |
| Destination unavailable or acknowledgement uncertain | Support owner, with the delivery coordinator | Check the destination by reference before any replay |
| No approver available | Business owner | Names an authorised delegate. Never auto-approve silently |
| Source records don't match | Data owner | Confirms which record is correct before the request continues |
If the workflow is unavailable, a manual fallback records the same reference and decision, and the two are reconciled before automation resumes.
What must be agreed before development starts?
Development is one stage, not the whole job. Before it starts, agree:
- Discovery. The workflow, users, rules, records and exclusions above, confirmed by the people who own them.
- Prototype validation. Business users try a rough version of the first slice with synthetic records before committing to the full implementation.
- Implementation and testing. Each critical requirement is checked against its acceptance outcome, including the failure cases.
- Controlled rollout. Who decides it is ready, how a small group starts, and how to return to the old way if needed.
- Support and change ownership. Who answers alerts, fixes faults, approves rule changes and keeps documentation current.
Existing systems keep their owners. Settle licences, source-code access, data export, hosting and support terms in the agreement, rather than assuming any of them come automatically with "custom".
How to decide whether the scope is ready
Use this checklist before asking for a build estimate. An unchecked item doesn't always mean stop, but it may mean pause, simplify or configure first.
- The business outcome and process boundaries are written down, with observations kept separate from suspected causes.
- The application owner has checked existing features and configuration options.
- Users, decision authority, source records and exclusions are agreed.
- Each critical requirement has an observable acceptance outcome and a named reviewer.
- Missing, rejected, changed, unauthorised and duplicate or uncertain cases each have defined handling.
- Interfaces and access have been verified in the intended environment, not inferred from a logo on a website.
- Responsible owners have specified data, access, retention, performance and recovery constraints. Unresolved targets stay open rather than being silently accepted.
- Support, documentation, change approval, backup and recovery, and exit or export responsibilities are agreed. These are discussion points, not a compliance certification.
- Business users can validate the first slice with synthetic or properly authorised test records before rollout.
- Acceptance evidence is recorded. A demo that looks right isn't enough, and releasing is a separate authorised decision.
When the first slice is running, measure the workflow automation benefits against a fair baseline rather than assuming them.
Sources
Official documentation and guidance, checked 16 November 2026. Product documentation shows that product's documented behavior, not every system's.