Skip to main content

Technical writing

Notes from production systems

Writing drawn from the same domains as my case studies, generalised so that nothing employer-specific appears. Where a piece draws on professional work, the grounding is stated on the article itself.

Published3

Published articles

  • Article5 min read

    Designing Microservices for Financial Systems

    Service boundaries in a payments platform are not an architectural preference, they are a correctness decision. How money, state and failure change the usual microservices advice.

    Read article
  • Article5 min read

    Building Reliable Payment and Transfer Integrations

    A field guide to integrating banks, mobile-money operators and billers, written from the perspective that every provider will eventually behave in a way its documentation does not describe.

    Read article
  • Article5 min read

    Lessons From Building Production APIs

    An API is a promise you have to keep after you have forgotten making it. What ten years of building integration surfaces teaches about versioning, errors, contracts and the clients you cannot upgrade.

    Read article
Content strategy

The series, and why these topics

Twelve pieces mapped to the engineering I have actually done: payments and integration, service architecture, delivery infrastructure, applied ML and leadership. Each planned piece lists its outline rather than a fabricated publication date.

Grounded, not generated

Every topic maps to documented experience. Nothing here is a trend piece on a technology I have not shipped.

Generalised by default

Articles describe principles and patterns. Professional work appears only in sanitised form, and is labelled as such.

Authority through usefulness

The goal is writing an engineer would bookmark, not keyword pages. Search visibility is a by-product of that, not the brief.

Planned9
  • PlannedLaravel · PHP

    Laravel Microservices Architecture

    Laravel is usually taught as a monolith framework. What it takes to run it as a fleet of services, boundaries, shared contracts, queues and the parts of the framework you stop using.

    Outline
    • Why teams reach for Laravel services, and when a modular monolith is the better answer
    • Which framework conveniences stop being conveniences across a service boundary
    • Shared contracts without a shared database
    • Queues, jobs and the delivery guarantees Laravel actually gives you
    • Containerising a PHP service so it deploys like any other service
  • PlannedJava · Spring Boot

    Java and Spring Boot for Financial Systems

    Why Spring Boot keeps showing up in payments infrastructure, and the framework-level decisions that matter when the domain is money rather than CRUD.

    Outline
    • What Spring Boot gives a financial service that a lighter framework does not
    • Transaction boundaries, and where @Transactional stops helping
    • Modelling money: why the primitive you choose is a correctness decision
    • Resilience patterns at the dependency edge, timeouts, bulkheads, circuit breakers
    • Testing a service whose dependencies you cannot call
  • PlannedPropTech · Architecture

    Designing Scalable Property Management Platforms

    PropTech is listings plus tenancy plus operations plus a great deal of media. A look at where those concerns actually want to be separated, and where splitting them costs more than it saves.

    Outline
    • The four concerns inside every property platform, and how differently they change
    • Media as a first-class architectural dependency rather than an upload feature
    • Designing an API that a mobile client several versions behind can still call
    • Where search belongs, and when it stops being a database query
    • What a serving-layer model changes about a page's latency budget
  • PlannedCI/CD · DevOps

    Building CI/CD Pipelines for Production Applications

    A pipeline decides how often a team can safely change its mind. What belongs in one, what does not, and why the rollback path deserves more attention than the deploy path.

    Outline
    • What a pipeline is actually for, and why 'automation' is the wrong framing
    • Stage design: fast feedback first, expensive checks later
    • Build once, promote the same artefact, and what breaks when you do not
    • Secrets, environments and the configuration boundary
    • The rollback path is the feature; the deploy path is the demo
  • PlannedDocker · DevOps

    Docker in Production Engineering

    Containers are straightforward until they are production. Image discipline, process supervision, resource limits and the operational habits that separate a container that runs from one you can operate.

    Outline
    • Image layers, build caching and why your rebuilds are slow
    • One process per container, and what to do when that is inconvenient
    • Configuration, secrets and the twelve-factor parts worth keeping
    • Health checks, signals and graceful shutdown
    • Resource limits: the setting people skip and then page about
  • PlannedAPI Integration · Payments

    Integrating Third-Party Financial APIs: A Provider Onboarding Checklist

    The practical companion to reliability theory, the questions to ask a new financial provider before writing a line of integration code, and the ones whose answers change your architecture.

    Outline
    • The semantics question: what does a 200 mean here?
    • Duplicate behaviour, reference formats and identity
    • Callback reliability, replay and verification
    • Sandbox fidelity, and planning for the ways it lies
    • Rate limits, settlement windows and operational calendars
    • The reconciliation conversation to have before go-live, not after
  • PlannedTechnical Leadership · Engineering Management

    Lessons From Leading Engineering Teams

    Notes on the transition from owning code to owning outcomes: sprint planning, mentoring, technical decision-making, and the parts of leadership that are simply engineering at a different altitude.

    Outline
    • The first shift: from 'is this correct?' to 'is this the right thing to be correct about?'
    • Mentoring as a design activity, not a scheduling one
    • Sprint planning when the estimate is genuinely unknown
    • Making technical decisions reversible where you can, and explicit where you cannot
    • Talking to stakeholders about risk without either alarming or reassuring them falsely
  • PlannedReact · Next.js

    React and Next.js Architecture for Large Applications

    What holds up as a React codebase grows past the point where any one person has read all of it, boundaries, data ownership, rendering strategy and the cost of the wrong default.

    Outline
    • Feature boundaries that survive a year of changes
    • Where data fetching belongs, and what the server can own
    • Rendering strategy as an architectural decision rather than a per-page flag
    • State: the four kinds, and why conflating them causes most refactors
    • Designing the client for an API contract you do not control
  • PlannedMachine Learning · TensorFlow Serving

    Machine Learning Inference With TensorFlow Serving

    Putting a model behind a user-facing request is an availability problem before it is a modelling one. Serving, versioning, latency budgets and what the page does when the model is slow.

    Outline
    • Why a served model beats an embedded one once the model is in a request path
    • Model versioning and the rollback you will eventually need
    • Batching, latency budgets and the cost of the tail
    • Designing the degraded path: what renders when inference times out
    • Monitoring a model in production without a labelled ground truth

Contact

Let’s Build Something Meaningful

I’m open to senior and lead engineering roles internationally, backend, full-stack, architecture and platform work. The fastest route is email; LinkedIn works just as well.