By the time the District Line finally coughed me out at Monument, I’d already made three decisions that morning: the overpriced croissant was worth it, the umbrella was not, and the train map remained a work of fiction. When you commission bespoke software, the early stages can feel very similar — lots of lines going in promising directions, but if you miss a single connection, you’re delayed and paying more than you planned. At Atreon, we’ve seen the same commuter chaos play out in software projects across London and beyond: great intent derailed by fuzzy outcomes, undocumented assumptions, and heroic sprints that shouldn’t have been necessary in the first place.
The good news? Costly mistakes are avoidable. Commissioning bespoke software isn’t an act of faith; it’s a craft. It’s assembling a team, a clear plan, and an honest budget — then running a calm, transparent process where surprises are rare and useful. The even better news? Doing this well doesn’t slow you down. It gets you to value sooner by cutting fluff and focusing on outcomes that matter.
This article distils what we’ve learned delivering software for organisations from Automotive to Construction — and fixing the odd project that’s nosedived. You’ll get practical guidance to help you commission software with confidence, structure, and fewer “oh dear” moments.
One quick anecdote before we dive in. A client once described their previous vendor selection as “like choosing a builder from a pub chat”. Charming. The result? A beautiful homepage, an admin area shaped by whimsy, and a test suite that might have been written in invisible ink. We helped them recover — but we’d prefer you didn’t need rescuing in the first place.
Avoid expensive missteps by doing three things well: define outcomes with measurable success criteria, validate scope early with real users, and govern delivery with ruthless transparency.
Start with outcomes, not features
Features are sticky. Once they’re on a list, they rarely come off. That’s how costs creep. Start with outcomes instead: what changes in your business when this software is live?
- Clarify the business goal: reduce fulfilment time by 30%, increase lead conversion by 15%, cut onboarding from 10 days to 2 — specifics, not vibes.
- Define measurable success criteria and when you’ll measure them. Write them as acceptance tests for the whole project.
- Prioritise the smallest set of features that prove or disprove your hypothesis. That’s your first release.
- Classify everything as Must, Should, Could, or Won’t (for now). Real adults use “Won’t” without flinching.
When outcomes lead, budget and timeline follow reality, not hope.
Scope collaboratively and document decisions
The biggest hidden cost in bespoke software is unspoken assumptions. You can’t price what you haven’t articulated.
- Run short discovery workshops with the people who know the work — not just the people who sign it off.
- Map end-to-end journeys and the backstage processes that support them. Service blueprints are unfashionably useful.
- Sketch wireframes or clickable prototypes to sanity-check flows.
- Record assumptions, constraints, and risks. Keep a living log. Revisit it weekly.
We produce lightweight “scope artefacts” at Atreon — journeys, diagrams, decisions — that anyone can understand. They kill ambiguity without drowning you in documentation.
Budget with eyes open: the total cost of ownership
Software doesn’t end at “it works on my machine”. Avoid the classic trap of pricing only the build.
Budget honestly for:
- Hosting and infrastructure (plus growth headroom)
- Third‑party services and licences
- Data migration and cleaning (the long-lost CSVs will not clean themselves)
- Security and compliance work (from threat modelling to audits)
- Observability and analytics (logs, traces, dashboards)
- Training, documentation, and change management
- Ongoing support, SLAs, and a runway for enhancements
A candid TCO conversation up front reduces painful surprises later. We sometimes suggest structuring budget in two envelopes: Build and Run, reviewed together every month.
Choose the right commercial model and governance
How you pay shapes how a team behaves.
- Fixed price with a clear, frozen scope can work for short, well-understood projects.
- Time & Materials is honest for evolving scope — but cap it, and tie spend to outcomes, not hours.
- Hybrid models (capped T&M for discovery, then outcome-based milestones) are often the sweet spot.
Whatever you choose, add simple governance:
- A fortnightly steering session with clear RAG status, risks, and decisions needed
- A single product owner empowered to make trade-offs
- A change control mechanism that’s fast and fair (and doesn’t punish learning)
Governance isn’t bureaucracy; it’s insurance against drift.
Design for users first, engineers second — bring both to the table
The most expensive fix is the one made after launch. The second most expensive is the one built beautifully but not wanted.
- Talk to actual users. Five to seven interviews will change your backlog.
- Prototype the knotty bits. Ugly prototypes save beautiful budgets.
- Bake in accessibility (WCAG 2.2), performance budgets, and mobile realities from day one.
- Capture non‑functional requirements (NFRs) early: response times, uptime, data residency, auditability.
Make integration a first‑class citizen
Integrations are where costs go to holiday. Treat them like product features with their own acceptance criteria.
- Map data contracts, API versions, rate limits, and SLAs before committing to timelines.
- Secure test environments and representative data early. “We’ll get sandbox access next month” is a red flag.
- Plan for failure: retries, idempotency, dead‑letter queues, backoff strategies.
- Write adapters, not spaghetti. Today’s friendly ERP can be tomorrow’s burning platform.
The cheapest integration is the one that’s honest about what it can and can’t do.
Reduce risk with thin slices and early releases
Big‑bang releases are dramatic and expensive. Boring is better.
- Start with a “walking skeleton”: a thin end‑to‑end slice that proves your architecture and de‑risks the unknowns.
- Release behind feature flags. Expose value to a small cohort. Watch the numbers. Adjust.
- Keep environments close to production. If your staging is a fantasy land, your launch will be a fairy tale with a bad ending.
- Show working software every week. Demos make abstract choices obvious.
Small releases turn scary problems into solvable ones.
Quality is a habit, not a phase
If your plan includes “we’ll test at the end”, your plan includes “we’ll be late and sad”.
- Define Done: code reviewed, tests passing, performance assessed, security checked, documentation updated, demoed.
- Build a testing pyramid: unit, integration, contract, and a modest number of end‑to‑end tests.
- Automate CI/CD with real gates: no passing tests, no merge.
- Add observability from day one: logs, metrics, traces, alerts, dashboards. If you can’t see it, you can’t fix it.
- Security is non‑negotiable: dependency scanning, secrets management, least privilege, periodic pen tests.
Boring, repeatable quality practices are cheaper than heroics.
Own your IP, your data, and your roadmap
Commissioning doesn’t mean ceding control.
- Ensure you own the IP for custom code. Open‑source where it helps, but know what you’re signing.
- Keep repositories, infrastructure accounts, and CI/CD under your organisation’s control.
- Insist on documentation that’s good enough for another team to take over.
- Demand admin‑level access, not PDFs. If handover needs a séance, something’s wrong.
Vendor lock‑in is a choice. Choose freedom.
Keep talking: cadences that actually work
Meetings can burn time and goodwill. Use them wisely.
- Weekly 30‑minute product review: demo, decisions, what’s next.
- Fortnightly steering group: budget, risks, dependencies. Everyone leaves with actions.
- Shared, lightweight dashboard: burn‑up, lead time, risk log, RAG status, key metrics.
- Clear comms etiquette: decisions in writing, channels with purpose, stakeholders who know where to look.
Silence is expensive. Transparency is a discount.
Spot red flags early
A few warning signs that trouble is brewing:
- Estimates presented without assumptions
- “We’ll figure out integration later”
- Demos replaced by slide decks
- Unowned product decisions (lots of stakeholders, no product owner)
- Team turnover with no explanation
- A vendor who never says “no” — charming, but not cheap
If you see these, pause. Re‑ground your scope and plan. It’s braver (and cheaper) to reset early.
When to call in reinforcements
Sometimes the horse has bolted and it’s rude to blame the stable door. If your project is sliding, bring in a calm second pair of eyes. A short audit can pay for itself: architecture review, delivery diagnostics, a reset backlog, a governance refresh.
We’ve stepped into rescue briefs before. To quote one client in Automotive:
“Working with Atreon has been an outstanding experience from start to finish... The final product not only meets but exceeds our expectations in terms of functionality and performance.”
And
“What has made the difference for us is that nothing ever feels too much trouble... They are clearly focused on finding a solution rather than creating a barrier.”
If you need that sort of energy, you know where we are.
A quick commissioning checklist
Use this to keep yourself honest:
- Outcomes and success metrics written down, shared, agreed
- Clear Must/Should/Could/Won’t priorities
- Documented journeys, prototypes, and integration contracts
- Transparent TCO including build and run
- Sensible commercial model with change control
- Named product owner with decision rights
- Release plan based on thin slices and early validation
- Quality baked in: Definition of Done, CI/CD, tests, security
- Observability and analytics planned from the start
- IP, repos, and environments under your control
- Meeting cadences set; dashboard live; risks visible
Stick this on the wall. Or the fridge. Both work.
How Atreon helps keep projects on time and on budget
We’re a London‑based team that prefers clarity to drama. Our approach is straightforward:
- Discovery that sharpens outcomes and kills ambiguity
- Design and prototyping that make user value obvious
- Engineering that treats quality as muscle memory
- Delivery that is demo‑led, metrics‑driven, and pleasantly boring
We don’t win projects by promising magic; we win by shipping useful software without surprises. If you’d like a second opinion on a scope, a sanity check on a budget, or a recovery plan for a drifted build, we’re happy to help — briefly, honestly, and without the hard sell.
Closing thought (and one last anecdote)
A friend of mine once had a kitchen fitted by a team who forgot to measure the fridge. They built everything perfectly — except the gap where cold things go. The replacement cabinetry cost more than the fridge itself. Commissioning bespoke software is similar: measure the gap, twice. If you get outcomes straight, validate the bits that worry you, and keep the conversation rigorous, the rest usually clicks into place.
Bespoke software should feel like a good London commute on a sunny day: predictable, efficient, and with just enough serendipity to make you smile. Define what “arriving” means, check your connections, and don’t be afraid to ask the guard a question. And if you’d like a guide who’s done this route a few times, Atreon’s door is open.