Drive through
my work

A customer runs their operation on a tangle of spreadsheets and three disconnected apps. Staff re-key the same data five times a day, and every report is out of date the moment it's printed.

Designed a single Next.js + TypeScript application over a typed API layer, with an Expo build so field staff get the same data on mobile. One source of truth, synced in real time.

A five-step daily process collapsed into one. Re-keying — and the errors that came with it — gone.

A .NET backend buckles every Monday morning under peak load. Nobody can say why, and the team is firefighting instead of building.

Profiled the C# / .NET services, isolated a blocking database call on the hot path, and moved it to async processing with a cache. Added structured telemetry so the next bottleneck is visible before it bites.

Monday peak now handled with headroom. The team watches a dashboard instead of a pager.

Stakeholders keep asking 'can the product just do X?' — and every answer takes weeks of meetings and guesswork.

Stood up a working, data-backed prototype in days with React and Python — something clickable to react to, instead of another slide deck.

Decisions made in the room. Weeks of speculation replaced by a demo people could actually use.

Every environment is hand-built by hand. 'It works in staging' is a coin flip, and standing up a new region eats an entire sprint.

Codified the whole stack in Terraform and Bicep — networking, identity, and compute — so any environment is one reproducible command. Containerised the workloads with Docker for parity everywhere.

A new region now spins up in under an hour. Environment drift — and the debugging it caused — eliminated.

A security review flags the cloud setup: a flat network, over-permissioned identities, and secrets sitting in plain config.

Re-segmented the network, applied least-privilege identity, moved secrets into managed vaults — then put it all in code so the fix can't silently regress on the next deploy.

Review passed. The secure baseline is now the default state, not a one-off remediation.

Cloud spend is climbing month over month and nobody owns the number. Finance is asking hard questions.

Mapped resources to the workloads that actually need them, right-sized compute, and added autoscaling plus budget alerts directly in the infrastructure code.

Spend brought back in line with real usage — with guardrails in code to keep it there.

A prospect loves the demo but can't see how it survives contact with their real, messy architecture. The deal stalls in technical doubt.

Joined the presales motion as technical SME: ran a discovery session, mapped their actual systems, and built a tailored proof-of-concept against their environment — not a sandbox.

Ambiguity replaced with a concrete integration plan the customer's own engineers signed off on. The deal moved.

Requirements are a moving target — three stakeholders, three different versions of 'done', and a build that hasn't started yet.

Facilitated structured requirements gathering, then turned the vague asks into a written technical design and architecture, and got sign-off before a line of code was committed.

One agreed definition of done. The expensive rework that ambiguity guarantees was avoided entirely.

The software is sold — but now it has to live inside the customer's environment and talk to systems it has never met.

Deployed on-site into the customer's environment, integrated with their identity, data, and network architecture, and trained their team to operate it without us.

A self-sufficient customer running in production — an outcome, not an ongoing dependency.