Skip to content
Available for interesting opportunities

Senior Software Engineer

Building scalable software and solving complex engineering problems.

I design and build reliable, high-performance applications and distributed systems with a focus on scalability, maintainability, and real-world impact.

View My WorkDownload Resume
GitHubLinkedInEmail
About

About Me

AWProfile image placeholder — add public/profile.jpg
[YOUR LOCATION]

I'm a Senior Software Engineer passionate about designing scalable systems, building high-quality products, and solving challenging technical problems.

My work sits where software architecture meets delivery: breaking ambiguous product requirements into well-bounded services, choosing the data model that will still hold up in two years, and keeping the seams between systems explicit enough that the next engineer can reason about them.

I work across the stack — backend services and APIs that carry the load, and frontend interfaces that stay fast and accessible under real conditions. On the infrastructure side I'm comfortable owning cloud environments end to end: infrastructure as code, containerised deployments, CI/CD pipelines, and the observability needed to run them.

A large part of my job is performance: profiling before optimising, removing N+1 queries and redundant network hops, adding caching where the data model actually allows it, and holding p95 latency to a budget rather than an average.

The rest is leadership — technical design reviews, RFCs, pragmatic code review, and mentoring engineers into ownership. I'd rather raise the team's ceiling than be the single person who understands the system.

Years Experience
[8+]Years Experience
Projects
[30+]Projects
Requests Served
[10M+]Requests Served
Engineers Mentored
[6+]Engineers Mentored
Skills

Technical Expertise

The tools I reach for most often, grouped by where they sit in a system.

  • Languages

    • TypeScript
    • JavaScript
    • Python
    • Java
    • Go
    • SQL

  • Frontend

    • React
    • Next.js
    • Tailwind CSS

  • Backend

    • Node.js
    • REST APIs
    • GraphQL
    • Microservices

  • Cloud & DevOps

    • AWS
    • Docker
    • Kubernetes
    • Terraform
    • CI/CD

  • Databases

    • PostgreSQL
    • MySQL
    • MongoDB
    • Redis

  • Architecture

    • System Design
    • Distributed Systems
    • Event-Driven Architecture
    • Scalability
Career

Experience

Roles, ownership and the outcomes that came out of them.

  1. [START DATE] — Present

    Current

    Senior Software Engineer

    [COMPANY NAME][LOCATION]

    Technical owner for [PRODUCT AREA], covering architecture, delivery and production reliability.

    • Designed and operated scalable services handling [X]M+ requests/month with a [X]% availability target.
    • Reduced p95 application latency by [X]% through query optimisation, caching, and removing synchronous work from the request path.
    • Led the migration from [OLD ARCHITECTURE] → [NEW ARCHITECTURE] with zero planned downtime.
    • Mentored [X] engineers, introduced design review practice, and raised deployment frequency to [X]/week.
    • TypeScript
    • Node.js
    • PostgreSQL
    • Redis
    • AWS
    • Kubernetes

  2. [START DATE] — [END DATE]

    Software Engineer

    [COMPANY NAME][LOCATION]

    Full-stack delivery on [PRODUCT AREA], from API design through to the customer-facing interface.

    • Built and shipped [FEATURE], adopted by [X] of active accounts within [X] months.
    • Cut build and deployment time by [X]% by rebuilding the CI pipeline and adding artifact caching.
    • Introduced [TESTING / OBSERVABILITY PRACTICE], reducing production incidents by [X]%.
    • React
    • Next.js
    • Node.js
    • GraphQL
    • PostgreSQL
    • Docker

  3. [START DATE] — [END DATE]

    Software Engineer

    [COMPANY NAME][LOCATION]

    Early-career delivery across product and platform work in a small engineering team.

    • Delivered [X] production features across the web application and its supporting APIs.
    • Automated [MANUAL PROCESS], saving an estimated [X] hours/month of engineering time.
    • Improved frontend load performance by [X]% through code splitting and asset optimisation.
    • JavaScript
    • React
    • Python
    • MySQL
    • AWS
Projects

Selected Work

Three systems where the interesting part was the constraint, not the feature list.

  • 01

    AI Platform

    Production LLM platform

    CodeLive Demo

    Scalable AI application with asynchronous processing and production-grade APIs, built around a durable job pipeline rather than long-lived request handlers.

    Technical challenge

    Model calls are slow, expensive and fail unpredictably. The platform pushes every inference through a queued worker pool with idempotency keys, per-tenant rate limiting and streamed partial results, so a provider timeout degrades one job instead of the request path.

    • Next.js
    • TypeScript
    • Node.js
    • PostgreSQL
    • Redis
    • AWS
  • 02

    Distributed Processing System

    High-throughput pipeline

    CodeLive Demo

    High-throughput background processing platform designed for reliability and horizontal scalability across an unpredictable, bursty workload.

    Technical challenge

    Throughput had to scale horizontally without duplicating work. Partitioned consumers, exactly-once semantics through transactional outbox writes, and dead-letter handling with replay keep the system correct while consumers are added, removed or restarted mid-flight.

    • Go
    • Kafka
    • Redis
    • PostgreSQL
    • Kubernetes
  • 03

    Developer Analytics

    Engineering delivery insights

    CodeLive Demo

    Engineering analytics platform providing insights into development activity and delivery performance across repositories and teams.

    Technical challenge

    Aggregating millions of events into sub-second dashboards ruled out querying raw data directly. Incremental rollups, materialised views and a GraphQL layer with per-field cost limits keep queries bounded no matter how wide the selected time range is.

    • Next.js
    • TypeScript
    • GraphQL
    • PostgreSQL
System Design

How I Think About Systems

A reference shape I keep coming back to: push work to the edge, keep services stateless, and move anything that can wait off the request path.

“I focus on designing systems that are simple enough to understand, resilient enough for production, and flexible enough to evolve.”

Edge before origin

Cache aggressively at the boundary so the majority of traffic never reaches a service that can fail.

Stateless services

Keep state in stores built for it. Services stay disposable, which makes scaling and recovery uneventful.

Async by default

Anything that can tolerate delay leaves the request path, so a slow dependency never becomes a slow page.

Principles

Engineering Principles

The defaults I bring to a codebase before anyone asks me to.

  • Keep It Simple

    Solve the actual problem before introducing unnecessary complexity.

  • Design for Scale

    Build systems that can evolve as traffic and requirements grow.

  • Measure First

    Use observability and data rather than assumptions.

  • Automate

    Reduce repetitive work through automation and tooling.

  • Build for Failure

    Assume components will fail and design systems accordingly.

  • Enable Others

    Good engineering includes documentation, mentoring, and knowledge sharing.

Have an interesting problem?

Let's build something great.

I'm always interested in challenging engineering problems, ambitious products, and opportunities to build meaningful software.

Get In TouchLinkedIn

Direct

[YOUR EMAIL]