Skip to main content

Available for freelance & consulting

Software that works. And the tests to prove it.

I'm Akeem Baker — a Quality Engineer. A decade of understanding how systems fail now shapes how I design, build and ship them: deliberate architecture, sharper trade-offs, and far fewer expensive surprises.

how i engineer
  • 10+ years across testing, automation & delivery

  • Architecture chosen for what it costs to change later

  • Proven continuously — tests, types & accessibility in CI

  • Full-stack delivery: Next.js, React & TypeScript

About

Knowing how software breaks changes how you build it.

I'm Akeem Baker — a Quality Engineer. That understanding is what shapes the architecture I choose, the trade-offs I make, and the software I hand over.

Across functional, regression and UAT testing — and automation built in Playwright, Selenium and TestComplete — I watched the same failures repeat: unclear boundaries, hidden coupling, and decisions made by default rather than on purpose. Those patterns are what I now design against, long before anything is written.

Today I pair that with full-stack development in TypeScript, React and Next.js. You get one person who can shape the architecture, build the feature and prove it works — fewer handoffs, and fewer gaps between what was intended and what gets delivered.

The goal never changes: reduce what can go wrong, and leave you with software that stays cheap to change and safe to build on long after handover.

Work

Selected work & case studies

In-depth case studies of selected projects — the problems, the engineering decisions I made, and the outcomes delivered.

  • Architecture of the Landlord App: a two-sided platform where landlords and tenants each get their own experience but share one system, backed by Supabase with Row Level Security, all built around a shared tenancy.
    Personal2026 – present

    The Landlord App: Property Management, Built Quality-First

    A two-sided property management platform for self-managing UK landlords and their tenants — and a look at how I design a product for reliability, security and long-term growth from day one.

    • Next.js
    • TypeScript
    • Supabase
    • PostgreSQL
  • The homepage of this website: the hero headline alongside a credibility panel listing experience, architecture, continuous testing and full-stack delivery.
    Personal2026

    This Website: Built to the Standard I'd Apply to Yours

    A consulting site is easy to fill with claims about engineering standards. I built mine so the claims are checkable — the architecture, the trade-offs, and the automated gates every change has to pass before it ships.

    • Next.js
    • TypeScript
    • Testing
    • Accessibility

Services

Bring me in to design it, build it, or prove it works.

Engagements across the software lifecycle — from the architecture decisions that are expensive to reverse, through delivery, to the testing that shows it holds up.

  • Architecture & Technical Design

    The decisions made before any code exists — how data is modelled, where boundaries sit, who is allowed to see what — are the ones that are most expensive to undo later.

    I model your domain, define the boundaries, and design the data and security architecture up front, with every significant trade-off written down and explained rather than buried in someone's head.

    A system that can grow without being rebuilt, and a team that understands why it's shaped the way it is.

  • Application Development

    You need a working product built properly — not a fragile prototype you'll pay to replace within a year.

    I design, build and ship web applications end to end in TypeScript, React and Next.js, with tests written alongside the code instead of bolted on before release.

    Software that works on launch day and stays cheap to change long afterwards.

  • Test Automation

    Manual regression testing is slow and expensive, and defects still reach production between releases.

    I build maintainable automated suites — unit, integration and end-to-end — wired into your pipeline so every change is checked before it ships.

    Faster, safer releases, and confidence that new work hasn't broken what already worked.

  • Manual & Exploratory Testing

    Automation only catches what someone thought to check. It's the unknown unknowns that reach your users.

    Hands-on functional, regression, UAT and API testing that probes the paths nobody specified — which is where the expensive defects usually hide.

    Problems found before your customers find them, and an honest picture of what actually works.

  • Quality Strategy & Review

    Testing feels ad hoc, nobody quite agrees what "ready to release" means, and it's unclear where the real risk sits.

    I review how you build and test today, then shape a pragmatic risk-based strategy — and coach your team to raise the standard without slowing delivery down.

    Release decisions grounded in evidence, and a team that holds the line after I've gone.

  • AI-Assisted Delivery

    AI tooling promises speed, but used without judgement it quietly ships insecure, unmaintainable code that somebody still has to own.

    I bring AI into the workflow deliberately — accelerating the work while keeping architecture, review and security standards intact.

    The speed advantage, without inheriting a codebase nobody understands.

How I work

Quality isn't a phase. It runs through every step.

No black boxes. Here's how a typical engagement runs — and the quality practice built into each stage, rather than bolted on before release.

  1. 01

    Discovery

    I start by understanding your goals, your users, and your constraints — so we build the right thing, not just any thing.

    Quality built in: I ask what could go wrong as early as what should go right. Risks found at this stage cost nothing to fix.

  2. 02

    Shape & plan

    We agree scope, approach, and a clear plan up front, so there are no surprises on timeline or budget.

    Quality built in: Scope is prioritised by risk, so the areas most likely to hurt you get the most attention — not just the loudest features.

  3. 03

    Design & architect

    I model the domain and choose the structure your software will grow into — the decisions that are expensive to reverse later.

    Quality built in: The design makes correct behaviour easy to build and incorrect behaviour hard. The cheapest defect is the one the architecture won't allow.

  4. 04

    Build

    I develop in small, reviewable increments with regular check-ins, so you always see progress.

    Quality built in: Tests are written alongside the code, not after it, so each increment arrives already proven rather than waiting on a testing phase.

  5. 05

    Prove & release

    I ship to production with documentation and a smooth handover — no lock-in, no mess.

    Quality built in: Automated checks — tests, types, accessibility — all have to pass before anything ships. Releasing becomes a decision backed by evidence, not a hope.

  6. 06

    Support & evolve

    After launch I'm available for maintenance, improvements, and ongoing support as your needs change.

    Quality built in: The test suite evolves with the product, so changes stay safe long after launch instead of getting riskier over time.

Tools I work with

The stack I reach for to build and test modern web applications.

Test Automation

  • Playwright
  • Selenium
  • TestComplete
  • API Testing

Languages & Data

  • C#
  • TypeScript
  • JavaScript
  • SQL

Web

  • Next.js
  • React
  • Tailwind CSS
  • Node.js

Delivery & Tooling

  • Azure DevOps
  • Git
  • CI/CD
  • Agile & Scrum

FAQ

Frequently asked questions

The things clients usually want to know before we work together.

Contact

Let's reduce the risk in your next project

Whether you have a defined project or just want to talk an idea through, I'll help you figure out the right approach — no obligation, no hard sell.

Currently available for freelance and consulting work.

I usually reply within 1–2 business days.