Software development

A lattice of connections underpinning a moving flow

Operational platforms

The tool your team actually spends the day in. Built around your process rather than a package you have to bend the operation around, and fast enough to use on a warehouse tablet.

Customer and supplier portals
Order, booking and despatch management
Workflow, task and exception handling
Mobile-friendly floor and driver interfaces

Nodes joined by routes, representing systems exchanging data

Integration & EDI

Making systems that were never designed to talk to each other exchange data reliably, with proper error handling and an audit trail you can show a customer.

ERP, WMS and TMS integration
EDI (EDIFACT, X12) and flat-file exchange
Carrier, marketplace and courier APIs
Middleware, queuing and retry design

Layered bands of information stacked one on another

Data, reporting & BI

One trusted set of numbers. Warehoused, modelled and surfaced so the operations meeting argues about what to do rather than whose figures are right.

Data warehouse and reporting pipelines
Operational dashboards and KPI packs
Cost-to-serve and profitability models
Automated distribution of daily and weekly reporting

Rings radiating outward, suggesting replacement in stages

Legacy modernisation

The critical spreadsheet, the Access database, the app whose author left in 2016. We replace them incrementally, without a big-bang cutover the business cannot absorb.

Assessment and risk mapping of existing systems
Incremental replacement and strangler patterns
Data migration and reconciliation
Documentation and knowledge transfer

Route lines running unattended with regular marked stops

Automation

Removing the re-keying. If a person is copying between two screens, or a report is being assembled by hand every Monday, that is a job for software.

Document, invoice and order processing
Scheduled jobs and alerting
Rules engines for allocation and routing
Assisted decision tools and pragmatic use of AI

A connected network held steady over time

Support & managed development

Systems that matter need someone accountable when they break. We offer monitored support with clear response times, and a steady stream of small improvements.

Monitoring, backups and incident response
Defined response and resolution targets
Security patching and dependency upkeep
A monthly allocation of development time

How we build

Boring technology, delivered in small pieces

Operational software has to run every day at six in the morning when the pick wave starts. That rules out anything clever for the sake of it.

Proven tools, chosen for your teamWidely used, well-documented technology that another developer can pick up. No framework you cannot hire for.
Working software in weeksShort cycles with a demo at the end of each. You steer as it goes rather than reviewing a finished thing you cannot change.
Tested where it mattersAutomated tests around the rules that would cost you money if they were wrong — pricing, allocation, stock movements.
Yours to keepYour repositories, your cloud accounts, documented handover. We design the exit at the start, not when the relationship ends.

Talk about a build

asn-import.test.ts

// The rules that would cost money if they were wrong.

describe('ASN import', () => {

  it('is idempotent on duplicate delivery', async () => {
    const asn = fixture('DESADV-88214');

    await importAsn(asn);
    await importAsn(asn);   // EDI retry, same message

    expect(await stockOnHand('SKU-4471')).toBe(1200);
    expect(await movementCount(asn.id)).toBe(1);
  });

  it('rejects a line for a SKU we do not hold', async () => {
    const asn = fixture('DESADV-88215', { sku: 'SKU-NOPE' });

    await expect(importAsn(asn)).rejects.toThrow(UnknownSku);
    expect(await stockOnHand('SKU-4471')).toBe(1200);
  });

  // A short delivery must never be silently accepted —
  // that is how stock records start lying to you.
  it('quarantines a short delivery', async () => {
    const asn = fixture('DESADV-88216', {
      expected: 400, received: 380,
    });

    const result = await importAsn(asn);

    expect(result.status).toBe('quarantined');
    expect(result.variance).toBe(-20);
    expect(notifications.to('goods-in')).toHaveLength(1);
  });
});

Stack

What we tend to build with

We are not religious about it. If your team already runs a stack well, we will work in it rather than argue for a rewrite.

01

Front end

TypeScript · React · modern CSS · progressive enhancement

02

Back end

Node.js · PHP · Python · REST and GraphQL APIs

03

Data

PostgreSQL · MySQL · Redis · warehouse and reporting layers

04

Infrastructure

AWS · Azure · containers · managed UK and EU hosting

05

Integration

EDIFACT · X12 · SFTP · message queues · webhooks

06

Practice

Version control · code review · automated tests · CI/CD

A regular lattice of connections with a flowing line cutting across it

Restraint

What we will talk you out of

We are paid to build software, which is exactly why it is worth being clear about where we will argue against it.

Rebuilding something you could buyIf a package covers most of it, the rest is usually process rather than software. We will say so.
A big-bang replacementSwapping a core system in one go is how go-lives slip a year. Replacing it a piece at a time is slower to start and far faster to finish.
Automating a process that should be fixed firstAutomation makes a bad process faster, not better, and much harder to change afterwards.
Integrating a system you are about to replaceThat is two integrations instead of one, and the first gets thrown away.
Reporting nobody has agreed to act onA dashboard with no decision attached to it is a screensaver.

Flowing route lines with marked stops along the way

FAQ

Software development questions

For well-defined pieces of work, yes. For anything exploratory we prefer a fixed-price discovery phase followed by time-and-materials with a cap and a monthly review — it costs less overall than the padding a fixed price on vague requirements has to carry.

Often the best arrangement. We can lead, pair, review, or simply take the parts your team has no capacity for. We will follow your conventions rather than imposing ours.

You get everything — source, infrastructure definitions, credentials, documentation — and a handover session. There is no penalty and no proprietary layer holding you in.

UK or EU regions by default, in your own cloud account wherever practical. If you have specific residency, retention or certification requirements, tell us early and we will design to them.

Yes, and we do it regularly. We start with a short assessment of the code and the state of play, then give you an honest view on whether it is worth continuing or restarting.

Have a system that is holding you back?

Send us the shape of the problem. We will tell you what we would build, roughly what it takes, and whether buying something off the shelf would serve you better.

Book an intro call See the consultancy side

Software built by people who have walked the warehouse