~/ how-it-works

How we work.

No black box, no discovery theater. Here's exactly how a project goes from a first conversation to working, maintainable PHP – and how you'd pay for it.

01

Audit & scope

We read the code before we quote. You get a clear picture of what you actually have - the risks, the quick wins, and what the work will take - instead of a number pulled from the air. For a rescue, that's an honest health check of the codebase first.

02

Plan & agree

We write down the plan: what we'll build or fix, in what order, what you own, and a quote you approve before any work starts. No scope creep by surprise, no surprises on the invoice, no work you didn't sign off on.

03

Build & test

Senior engineers do the work in your repo, with tests and code review - not a junior learning on your dime. You see progress in small, reviewable steps, and you get PHP you can actually read and a history you can follow.

04

Ship & maintain

We deploy it properly, document it, and hand it over - or stay on a retainer to keep it healthy. Either way you're left with something maintainable, not a dependency on us. The code is yours, and so is the knowledge.

Engagement models

Work with us the way that fits.

A defined project, an ongoing retainer, an engineer embedded in your team, or a one-off audit – whichever matches how you work.

Fixed-scope project

A defined build or fix with a clear deliverable and a quote you approve up front. Best when you know what you need and want a predictable cost and timeline rather than an open-ended meter.

Monthly retainer

A senior PHP engineer on call for a set number of hours a month - patches, dependency updates, small features and the occasional fire. Best for keeping an existing app healthy without a full-time hire.

Embedded engineer

We slot a vetted senior PHP developer into your team, your tools and your standups. Best when you already have your own roadmap and management and just need proven hands on the keyboard.

Code audit (one-off)

A focused, fixed-price review of your codebase - security, performance, or a second opinion before you commit to a rebuild. You get a prioritized, plain-English report you can act on with anyone.

Pricing

A clear figure, approved before any work starts.

Every PHP project is different, so pricing is quote-based, not a fixed menu. We read the code or scope the work first, then give you a clear figure - fixed price for a defined build, an hourly or monthly rate for a retainer, or a flat fee for an audit. You see what's included and what you'd own before anything starts. Rescue and modernization work is scoped after a paid code audit, because nobody can honestly quote a codebase they haven't read. We charge senior rates because senior engineers do the work - but there's no junior padding and no per-seat games. We're a new studio being deliberate about our first clients, which means real capacity and genuine attention, so we'd rather scope it right with you than post a number that doesn't fit your project.

Get your quote →

Questions

The things clients ask us first.

Both - and existing code is a big part of what we do. We build new applications, and we take on existing PHP that other people have lost interest in or are afraid to touch. Legacy rescue and modernization is a headline service, not an afterthought, so an old, messy, framework-less codebase is welcome here rather than a problem.
Almost never. Most "hopeless" PHP is just code that grew without tests or structure - which is fixable. We start with a paid audit so we both understand what you actually have, then stabilize the urgent risks before improving anything. A full rewrite is sometimes right, but it's the last option we reach for, not the first, because it throws away years of working business logic.
We work in modern PHP 8.x and across the ecosystem - Laravel and Symfony for application frameworks, plus WordPress, WooCommerce and Drupal when the work is real engineering rather than page-building. We also handle plain, no-framework PHP, which is exactly what a lot of legacy rescue work turns out to be.
Yes - this is one of the most common things we're asked for. We do it in safe steps rather than a single risky jump: inventory what will break, get the code passing on the new version behind tests, and cut over deliberately. Where the host or the dependencies are also out of date, we sort that as part of the same plan so you're not left half-migrated.
You do - all of it. We work inside your repositories, servers and accounts, and your code and IP are yours in writing before we start. We document as we go so the knowledge lives with you, not locked in our heads. If you ever stop working with us, you keep everything and lose nothing but us.
It's quote-based, because every codebase and project is different. We scope the work - or audit the code - first, then give you a clear figure: fixed price for a defined build, an hourly or monthly rate for a retainer, or a flat fee for an audit. You approve it before work starts. We charge senior rates, but there's no junior padding and no surprise line items.
Yes. Plenty of clients keep us on a monthly retainer once the main work is done - security patches, dependency updates, small features and the occasional emergency - so they have a senior PHP engineer on call without a full-time hire. It's optional, though; if you'd rather take the code in-house, we hand it over cleanly and documented.
Tell us about the project on the start form and we'll reply - usually within one business day - with next steps. For a new build that's a scoping conversation; for a rescue it's a paid code audit that gives you a real plan and quote. We'll give you an honest start date based on current capacity rather than promising speed we can't hold.
Start a project

Tell us about your PHP. We'll tell you the truth.

New build, legacy rescue, or an app that needs a senior pair of hands – describe it and we'll reply with honest next steps, usually within one business day.

Start a project → How it works