How we work
No mystery, no methodology theatre.
A straightforward account of how an engagement actually runs - what we do first, what you see along the way, and who answers the phone afterwards.
The arc
Six stages, one team throughout.
The stages below are not a waterfall - they overlap and loop. What matters is that the same people are accountable across all of them.
- Architect Understand the work, model the domain, choose the shape. The decisions here cost the most to reverse.
- Design Interfaces and interactions designed around the people who will use them every day.
- Build Reviewed, tested increments. You see working software at the end of every iteration.
- Test Automated suites, integration, performance and acceptance - running continuously, not at the end.
- Host Environments built, secured and documented. Deployment made routine and reversible.
- Run Monitoring, response, patching and improvement. The longest stage by far.
Principles
Six things we will not trade away.
Decisions get written down
Every significant architectural choice is recorded with the reasoning and the options rejected. Three years on, when somebody asks why it works this way, the answer exists.
Boring dependencies, on purpose
We pick technology that will still be maintained and hireable-for in a decade. Novelty is a cost you pay every year, and it is rarely the client who chose it.
Working software, continuously
Short iterations, each ending with something you can actually use. Progress is visible throughout rather than revealed at a milestone.
Security is not a phase
Threat modelling at design time, dependency scanning in the pipeline, patching as routine. Not a penetration test bolted on the week before go-live.
Small teams, long relationships
The same engineers, year after year. We would rather grow slowly and keep people than staff up fast and rotate strangers through your codebase.
We will tell you not to build it
If the honest answer is a spreadsheet, an off-the-shelf product, or nothing at all, we will say so. It costs us a project and earns us a client.
Technology
What we build with.
A deliberately unfashionable list. These are platforms with long support horizons, deep talent pools and a realistic chance of still being a sensible choice when the system is ten years old.
Working in something not listed here? Ask - the list is what we reach for first, not the limit of what we will take on.
Languages
Applications & mobile
Embedded & devices
Operating systems & infrastructure
Data & integration
AI-assisted delivery
AI-assisted delivery
The best code is the code nobody had to write.
We build with the current generation of AI development tools - Claude among them. Not as a novelty, and not as a substitute for engineers: as a way to spend more of your budget on the decisions that determine whether a system works, and less on the mechanical parts of the job.
You buy judgement, not typing
Boilerplate, scaffolding and the first draft of a test suite are now largely mechanical. That moves the hours you are paying for onto design, domain modelling and the awkward decisions. The practical effect is more system for the same money.
Less code for you to own
The cheapest code to maintain is the code that was never written. We use these tools as readily to delete and consolidate as to produce: a smaller codebase is quicker to change, cheaper to run and far easier to hand over.
Working software sooner
Prototypes and spikes that used to take a fortnight take days. You make decisions against something you can actually use rather than a document, and you find out early when an idea does not survive contact with real data.
Tests and documentation stop being optional
Coverage and documentation are the first things dropped when a budget tightens, and the reason year three costs more than year one. When they are cheap to produce, they stop being the thing that gets cut.
Inherited systems become legible
Reading unfamiliar code is something these tools are genuinely good at. Work that used to mean months of archaeology - and then a nervous rewrite - becomes weeks of informed, incremental change.
A person is still accountable
AI drafts; engineers decide. Every line is reviewed by the person who will be supporting it out of hours, and nothing ships that we could not explain to you line by line.
What it does not change. It makes good engineers faster. It does not make poor architecture good, and it is not cover for putting inexperienced people on work that needs judgement. Knowing which of your problems is worth solving in software at all is unchanged - and that is still where most of the value sits.
Your code and your data. We use business-tier tooling under terms that keep client material out of model training, and we agree the boundaries with you in writing before we start - which systems and which data are in scope, and which are off limits. If your sector requires something stricter, say so at the outset and we will work to it.
Questions
The ones we get asked most.
Do you take on work that someone else started?
Can you host what you build?
Will we be handed to a different team once it is live?
Do you provide managed IT as well as development?
Do you use AI to write our code?
Where are you, and can we visit?
Next step
Tell us what you are trying to build.
A conversation costs nothing and usually clarifies the problem either way. We will tell you honestly whether we are the right people for it.
Or call 01746 740050