Skip to article
Automation Voice Agent Creative Blog Request a call Contact us
Automation

What Are Custom Software Solutions? From Workflow to Clear Scope

What custom software is, when configuration or integration is enough, and how to turn one workflow gap into requirements you can test.

Illustration: a workflow gap between two existing tools becomes a defined requirement, an approval step by a person and an acceptance check.
On this page

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

  1. 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.
  2. 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.
  3. 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.

Original MVO illustration. Choose the scope after checking the requirement.

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".

Suggested scoping questions, not a product recommendation or test result
Observed gapRoute to investigateEvidence before choosingStop or reconsider when
The existing application has the needed rule, but nobody uses itConfigure the existing featureThe application owner confirms the function, permissions and limits, and shows it working on a representative caseThe 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 themIntegrate through supported interfacesWhich record is authoritative, stable identifiers, approved access and the operations each system actually supportsThe 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 decisionA small custom workflow application or extensionNamed users, the specific missing behaviour, the exception path, acceptance checks and an operating ownerThe rule is still disputed, the benefit is unsupported, or nobody will own it in operation
People disagree about who approves a changeClarify the process before any softwareThe business owner defines authority and escalationNew 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.

Hypothetical example: requirements and proposed acceptance checks (a specification, not passed tests)
RequirementObservable acceptance checkOwner and evidence
R1: incomplete changes stay out of approvalSubmit test request CR-A without a service reference. It stays in Needs information, and no approval or handoff is createdThe account handler checks the displayed state and the stored record
R2: only an authorised manager decidesThe account handler tries to approve: the action is refused and the state doesn't change. A manager can approve a valid versionThe 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 decisionApprove version 1, then change the proposed work to version 2. The version 1 approval must not authorise version 2The service manager checks versions and the decision history
R4: rejected or pending requests never reach delivery as approvedReject CR-B and leave CR-C pending. Neither appears in the approved handoffThe delivery coordinator reconciles decision records against handoff records
R5: an uncertain handoff is reconciled before any replaySimulate the destination accepting CR-D while the acknowledgement is lost. Reconcile by stable reference before replaying; no second delivery task appearsThe implementer and support owner design duplicate control and test the real destination's behaviour
R6: acknowledgement is not work completionDelivery acknowledges CR-D. The request shows Accepted for delivery, not Work completedThe delivery coordinator checks the actual operational state
R7: unresolved failures stay visibleFail a handoff and exhaust the agreed safe recovery path. The request stays in the exception queue with a named ownerThe 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

  1. ReceivedAccount handler submits
  2. Ready for reviewRequired details are present
  3. ApprovedAuthorised service manager decides
  4. Handoff pendingSent to delivery by stable reference
  5. 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.

Hypothetical example Original MVO illustration. A service-change request is validated, reviewed by an authorised manager and acknowledged by delivery, with separate paths for missing details, rejection, changed terms and uncertain handoffs.

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.

Hypothetical example: who owns each exception
ExceptionOwnerWhat happens
Missing inputAccount handlerThe request stays in Needs information until it's complete
Disputed commercial changeService managerThe manager decides; software doesn't decide feasibility or price
Stale versionService managerThe new version needs a new approval
Destination unavailable or acknowledgement uncertainSupport owner, with the delivery coordinatorCheck the destination by reference before any replay
No approver availableBusiness ownerNames an authorised delegate. Never auto-approve silently
Source records don't matchData ownerConfirms 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.

Back to top