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

Work

Selected work & case studies

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

  • The Landlord App dashboard: an expiring-certificate alert at the top, summary tiles for properties, tenants and rent, then lists of properties, open maintenance and rent needing attention.
    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

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 are the patterns I now design against, before anything is written.

Today I pair that with full-stack development in TypeScript, React and Next.js — one person who can shape the architecture, build the feature and prove it works. Fewer handoffs, fewer gaps between what was intended and what ships, and software that stays cheap to change long after handover.

Most of that work starts inside something that already exists. I'm comfortable joining an established codebase, CI pipeline and Agile team, and I follow your conventions rather than importing my own.

Services

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

Testing, AI-assisted development and full-stack delivery — with quality engineered in from the first decision rather than inspected at the end.

  • Test Automation

    Manual regression testing is slow and expensive — and defects still reach production.

    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.

  • AI-Assisted Development

    AI can accelerate delivery dramatically — or quietly fill a codebase with insecure, unmaintainable code nobody understands.

    I build with AI as a deliberate part of the workflow, using it to move faster while holding the same standards for structure, review, security and test coverage.

    The speed advantage, without inheriting a codebase you can't maintain.

  • Application Development

    You need a product built properly — not a 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 — modelling the data and boundaries up front, then writing tests alongside the code.

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

  • 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.

    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 your team can actually sustain.

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

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.

  1. Discovery

    Understanding your goals, your users, and the constraints you're working within.

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

  2. Shape & plan

    Agreeing scope, approach and a clear plan before any work starts.

    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. Design & architect

    Modelling the domain and choosing the structure your software will grow into.

    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. Build

    Development in small, reviewable increments with regular check-ins.

    Quality built in: Tests are written alongside the code, so each increment arrives already proven.

  5. Prove & release

    Shipping to production with documentation and a clean handover.

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

  6. Support & evolve

    Maintenance, improvements and ongoing support — one-off or on a retainer, as your needs change.

    Quality built in: The test suite evolves with the product, so changes stay safe long after launch.

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

Contact

Let's reduce the risk in your next project

Send me a short description of what you're working on and we'll scope it on a quick call — whether that's a defined project or just an idea you want to talk through. No obligation, no hard sell.

Currently available for freelance and consulting work.