Skip to main content

Our approach

A senior engineer accountable for every change.

Blair, our founder, leads your project from the first conversation. Work goes out in small steps, and nothing goes live until it has been tested, reviewed and signed off. You see progress early, and you always know who is responsible.

changes / ACME-142merged

ACME-142 · Linear · priority high

Add CSV export to the invoices list

branch: acme-142checks: greenreview: approved
  1. Agreedacceptance criteria written, priority set with you
  2. Builton its own branch, with focused tests
  3. Verifiedtests, lint, type check and build pass
  4. Merge request !218 openedafter a code review
  5. Feedback addressed2 review threads resolved, CI green
  6. Approvedby a senior WheelHouse engineer
  7. Mergedticket moved to Done
Illustrative: one change, from ticket to merge.
reviewed and signed off by a senior engineer
every
change
each tested and released on its own
small
steps
for the personal data your service holds
UK
hosting
our longest client partnership
more than six
years

In plain English

What working with us looks like

  • How the work runs

    We agree priorities with you, then build in small steps. Each change is tested, reviewed and released on its own, so you see progress early and often, not all at once at the end.

  • What a release looks like

    Once work on a change starts, it takes about an hour and a half on average, including automated checks and Blair's review. Bigger pieces of work are broken into steps you can try as they land.

  • Who is accountable

    A senior engineer reviews and signs off every change before it goes live. Blair leads your project from the first conversation through launch and the years after.

  • How the code gets written

    It depends on the project. Some of our clients' software is written entirely by hand. On others, AI coding tools write code to a brief Blair has agreed with you. Either way, every change is tested, and Blair reviews it and signs it off.

  • How questions get answered

    When something is unclear, we ask rather than guess. Technical questions go to Blair, and decisions about your service come to you, in plain English. Other work carries on in the meantime.

  • What happens after launch

    Software needs looking after once it's live. We plan support and maintenance with you from the start and agree a monthly amount for it. Most clients stay with us after launch.

What we build

Web, mobile and the systems behind them

We choose tools for your situation, not our favourites, and tell you when an existing one would do the job.

  • Web applications

    Self-service portals, booking tools and admin systems that work on any device, with nothing to download.

    Seen in Compass and WelcoMe

  • Mobile apps

    iOS and Android apps, cross-platform or native, including apps that connect to hardware over Bluetooth.

    Seen in Button and Thistle Assistance

  • Custom software

    Systems built around how you work, replacing spreadsheets, manual steps and tools that don't fit.

    Seen in Thistle Assistance and Remappack

  • APIs and integrations

    Connections to payments, email, booking platforms and the tools you already use, so data is entered once.

    Seen in Remappack and WelcoMe

  • UK hosting and support

    Azure or AWS, with personal data hosted in the UK: secure by default, monitored and sized to real use, with support after launch.

    Seen in Thistle Assistance

  • Legacy modernisation

    An ageing system replaced piece by piece while it keeps running, from old apps to hardcoded WordPress themes.

    Seen in ARC Scotland websites

The rest of this page covers how changes are built, checked and kept secure, in technical detail. It's written for CTOs and developers, and you don't need any of it to work with us. Book a call instead.

How it works · for technical readers

From ticket to merged change

This is the path a change takes, whether an engineer writes it by hand or an AI coding tool writes it to a ticket. Work is tracked in Linear and your code host, unclear requirements become questions rather than guesses, and every step is visible as it happens.

  1. 01 · backlog

    Select

    The next eligible ticket is taken from Linear, by priority.

  2. 02 · build

    Build

    Implemented on its own branch, with focused tests.

    if anything is unclear

    engineer or client

    Ask, don't guess

    Unclear requirements become a question. Other work carries on.

  3. 03 · review

    Review

    Your checks and a code review, then a merge request.

  4. 04 · checks

    Checks

    CI and reviewer feedback are watched on every new commit.

    until everything is green

    review feedback

    Fix until green

    Feedback is fixed where justified and explained where not.

  5. 05 · engineer

    Approve

    Senior sign-off, then it merges and the ticket closes.

Coming soon

Next: release management

Once changes merge, the release will be automated too: tagged in git, published on GitHub or GitLab, and kept in step with Linear's release pipeline.

  1. coming soon

    Tag release

    Tags the merged work as a new version in git.

  2. coming soon

    Publish release

    Creates the release on GitHub or GitLab, with notes.

  3. coming soon

    Track release

    Keeps the Linear release pipeline in step.

Engineering principles

Built the way we build software

Speed only matters if the work holds up. These are the rules we build to, however the code is written. Where AI coding tools write it, they're built into the system itself, not left as guidelines a tool can choose to ignore.

Every change is a merge request

Each ticket gets its own branch and its own merge request, with a clean history. Nothing reaches your main branch unreviewed.

Verified before review

Your repository's own tests, linters, type checks and builds run before anyone is asked to look.

Green means green

A change merges only when required checks pass, required reviews finish and discussions are resolved, on the latest commit.

Small by default

Work is broken into tickets small enough to review properly. Anything larger needs an explicit go-ahead from the engineer.

Questions, not guesses

Conflicting requirements or a genuine product decision pause the ticket until a person answers. Other work carries on.

Recorded, not assumed

Each change is recorded against its ticket, with its checks, review and sign-off, so we can show you what was delivered.

Accountability

Who is responsible for what

Tools change. Accountability doesn't. Judgement comes from a senior engineer who has built and run production software for years, and decisions about your service stay with you.

  • You set the priorities. What gets built, and in what order, is agreed with you.

  • The engineer shapes the backlog. Tickets with testable acceptance criteria, sized and prioritised with you.

  • People make the decisions. An open question goes to the engineer, or to you. It's never left to a tool to guess.

  • The engineer validates every change. A senior engineer's approval is a required step before anything merges.

  • The engineer owns the architecture. Design, security and anything bigger than a ticket stay with the engineer. Large tickets need an explicit go-ahead.

questions1 waiting

ACME-157 · paused

Round per line, or once on the invoice total?

Acceptance criteria 1 and 2 disagree. AC1 rounds each line; AC2 expects the total to match the payment provider, which rounds once.

Your answer

  • Round each line (AC1)
  • Round once on the total (AC2)
  • Something else
Answer and resume

Meanwhile: ACME-158 in progress · ACME-159 in review

Illustrative. While a ticket waits for an answer, other work carries on.

Security scans · opt-in

An extra security scan for sensitive code

You can opt in to an extra check on sensitive code. When a ticket touches an area such as authentication, payments or personal data, every version of its merge request is scanned by two specialist AI security models that are not generally available, before the engineer's review.

WheelHouse has access to both through their makers' trust programmes. Like every AI service we use, they process the code in the EU, on business or API terms that don't allow training on it, and never see personal data from your service.

  • Two models, in parallel, read-only. They report what they find. They never change your code.

  • Every new commit is scanned again. A change merges only once the scan of its latest version passes.

  • Findings become review threads. They're fixed like any other review comment. A high or critical finding that is not fixed goes to a senior engineer.

  • Tested against known flaws. We evaluate the scan on code with planted vulnerabilities and clean controls, so we know what it catches and how often it raises a false alarm.

scans / !231passed

ACME-163 · security-scan

Save card details for repeat payments

scanners · read-only, in parallel

scanner-a2 found
scanner-b2 found
  • highCard token written to the request logfound by both · fixed in 4e1c2a9
  • mediumNo rate limit on adding a cardscanner-a · fixed in 4e1c2a9
  • lowDecline reason shown in full to the userscanner-b · explained, follow-up ACME-171
security-scan passed on 7f3b9e0 · merge unblocked
Illustrative scan, rescanned after the fixes.

How the code gets written

The tools vary by project. The checks don't.

Some of our clients' software is written entirely by hand. On other projects, AI coding tools write code to tickets a senior engineer has shaped, working through Voyager, our in-house delivery system. Which suits depends on the project, and if your organisation has an AI policy or a list of approved tools, we'll work within it.

Voyager takes well-defined tickets from a backlog and delivers them as tested, reviewed merge requests, under the same rules as any other change. It does not replace engineering judgement. A senior WheelHouse engineer shapes the work, answers the questions that come up and validates every change before it reaches your main branch.

Voyager in 15 seconds.

Where AI coding tools work on your code

  • A machine that is yours alone

    AI coding tools work on your code on a machine dedicated to you, in our Edinburgh office. Your repositories and credentials never share one with another client's.

  • No personal data

    They never see personal data from your service. They have no access to production databases, and logs are anonymised.

  • No training on your code

    Every AI service we use to write, review and scan code processes it in the EU, on business or API terms that don't allow training on it.

  • Scoped access

    That machine holds only the access it needs for your code host and tracker, and each ticket is worked on in its own worktree.

Fits your workflow

No new tools for your team

If you have developers or reviewers of your own, they keep using Linear and your code host, GitHub or GitLab. Leave a comment on a merge request and it's picked up and answered there.

Scheduled maintenance

Dependency upgrades on a cadence you choose, from weekly to annually. Each cycle is planned, ticketed and delivered like any other work.

cadence: monthly · tickets: review first

Cost

What this means for your budget

Automated checks run before anyone reviews a change, and we choose the tools for each project, AI coding tools among them where they suit. Senior time goes on the decisions that matter: what to build, how it fits together and whether it's right.

Once work on a ticket starts, it takes about an hour and a half on average, including automated checks and Blair's review. The checks take time on purpose: they catch most problems before a change goes live.

Software still needs looking after once it's live. We plan support and maintenance with you from the start and agree a monthly amount for it, so you know what keeping it running will cost.

Questions

What clients ask us

Something else on your mind? Ask us directly.

Do I need to understand any of this to work with you?

No. This page is for people who want the technical detail. All you need to know is that a senior engineer is accountable for every change, and you'll be told plainly what's happening and why.

Who writes the code?

It depends on the project. Some of our clients' software is written entirely by hand. On others, AI coding tools write code to acceptance criteria a senior engineer has agreed with you. Either way, the engineer makes the design and security decisions, and reviews and validates every change before it merges. Ask us, and we'll tell you how we'd build yours.

Does all this testing mean nothing can break?

No. Tests and reviews catch most problems before they reach you, but software still needs maintenance, updates and the occasional fix. That's why we stay on after launch.

What kind of work goes through Voyager?

Well-defined tickets with testable acceptance criteria: features, fixes, integrations and maintenance. Large or open-ended work starts with a senior engineer, who breaks it into tickets Voyager can deliver.

Where does my code live?

In your own repositories. Where AI coding tools work on it, they do so on a machine that is yours alone, in our Edinburgh office, never one shared with another client. The code they're working on is sent to the AI services that write and review it, and to the security-scan models if you've opted in to that scan. All of them process it in the EU, on business or API terms that don't allow training on it. Personal data from your service is never sent to them: they have no access to production databases, and logs are anonymised.

Which AI tools do you use?

Where a project uses them, Claude Code and Codex write code, and CodeRabbit reviews it. If you opt in to the extra security scan, code in sensitive areas is also scanned by Claude Mythos and OpenAI Daybreak Blue. We choose the tool for each step, so you are not tied to a single provider. If your organisation has an AI policy or a list of approved tools, we'll work within it.

Talk through your plans

Tell us what you want to build or improve. We'll explain how we'd approach it and what a first release could look like.

Reviewing a change together on a laptop