01
A process outgrew its spreadsheet
The workaround that held for three years now has five people maintaining it. It needs to become an application with rules, permissions and an audit trail.
Symfony development for business-critical applications
The application your business runs on should not be the one nobody wants to touch.
HOW MUCH Labs builds, extends, integrates and maintains Symfony applications — customer portals, internal platforms, APIs and the systems that quietly hold a company's operations together.
This is delivered development work, not developer placement. We take responsibility for the scope we agree.
Who leads the work
Projects are led by a developer with 20+ years of experience.
Architecture, technical decisions and code review sit with a senior lead — the part of a project that is expensive to get wrong and cheap to get right early.
- Structure decided before code is written
- Technical oversight across the whole delivery
- Written for the developer who inherits it
When companies call us
Four situations that usually start the conversation
02
An application nobody wants to touch
It works, but the developer who wrote it is gone and every change feels risky. We read it first, then tell you what is safe to change.
03
Two systems that will not talk
The website, the CRM and the back office each hold part of the truth. Somebody re-types data between them every day.
04
A version that is holding you back
An older Symfony release blocking upgrades, hosting changes or new functionality — and the jump keeps getting postponed.
What we build in Symfony
New applications, additions to existing ones, and the unglamorous work that keeps both running.
Build
Custom applications & platforms
Customer portals, booking and quoting tools, internal operations platforms — built around how the business actually works rather than around a template.
Integrate
APIs & system integrations
REST and messaging integrations with the ERPs, CRMs, payment and logistics systems the company already depends on, with failures logged rather than silent.
Extend
Work on existing applications
New functionality, refactoring and bug work inside a codebase we did not write. We start with an assessment so the first change is not the risky one.
Modernise
Legacy modernisation & upgrades
Moving an application onto a supported Symfony version, in stages, with the business running throughout.
Stabilise
Performance & reliability
Slow queries, timeouts, jobs that fail quietly at night. We find the actual cause before proposing a rewrite — a rewrite is rarely the cheapest answer.
Comfortable with
Symfony 2-8Doctrine ORMAPI PlatformREST & webhooksMessenger & queuesPostgreSQL / MySQLTwigPHPUnitDockerCI pipelinesLegacy upgradesHeadless frontends
How a project runs
Five stages. You know the scope and the cost before implementation starts.
1
Discovery
We learn what the application has to do and, for existing systems, read the code before forming an opinion. You get a written summary of what we found and what we would recommend — including the option of doing less than you asked for.
2
Scope
A written scope with a fixed price and a delivery date for the agreed work. Anything uncertain is named as uncertain here rather than discovered mid-build. Larger applications are split into stages you can review between.
3
Implementation
Built in visible increments on a staging environment, with the senior lead owning the architecture and reviewing what ships. You see progress as it happens instead of at the end.
4
Review
You test against the scope on staging. Automated tests cover the parts of the system where a silent failure would be expensive. Fixes inside the agreed scope are part of the price.
5
Handover
Source code, repository access, deployment instructions and documentation written for the next developer. If you want us to keep maintaining it, that is a separate agreement — not a condition of getting the code.
Maintainability & ownership
You should be able to leave us
An application you cannot hand to another developer is not an asset, it is a dependency. We build so that handing it over is a normal Tuesday.
Senior technical leadership matters most here: the decisions that make a codebase readable in three years are made in the first two weeks.
The code is yours
Full source and IP transfer on final payment. Nothing is licensed back to us and nothing depends on our infrastructure.
Framework conventions, not house style
We follow Symfony's own conventions so any Symfony developer can read the result — that is most of what maintainability means in practice.
Documented as it is built
Setup, deployment and the decisions that are not obvious from the code, written while they are still fresh rather than reconstructed at the end.
No lock-in by default
You can move the application to another team without asking us for anything. We would rather be kept than needed.
Working at an agency?
This page is for companies hiring us directly. If you are an agency or consultancy that needs Symfony delivery behind your own brand, that is a different arrangement — and it has its own page.
Questions clients ask first
Yes — most of our Symfony work is on existing applications. We start by reading the codebase and telling you what we found: how it is structured, where the risk sits, and what can be changed safely. That assessment is useful to you even if you never hire us for the build.
It is common and it is workable. An undocumented application takes longer to get into, so we scope the first stage as a paid discovery rather than guessing at a price for the whole thing.
That is a large part of the work: ERPs, CRMs, accounting packages, payment providers, internal databases, third-party APIs. Where an API exists we use it; where it does not, we agree a safe way to exchange data and document it.
We scope in writing before implementation: what is included, what is explicitly not, and a fixed price for the agreed work. Larger applications are split into stages so you can stop, review or change direction between them.
Whatever you prefer. Some clients take the codebase and continue in-house, some keep us on for maintenance and updates, some call us only when something needs adding. The handover is the same either way — full source, documentation and access.
Projects are led by a developer with 20+ years of experience, who owns the architecture and reviews what ships. Where a project needs more hands, that lead stays accountable for the result. HOW MUCH Labs is your contracting party, not an intermediary.
Project enquiry
Discuss your Symfony project
Tell us what the application does, or should do. A rough description is enough to start — we will come back with the questions that matter before anyone talks about estimates.
If the work turns out not to suit us, we will say so rather than quote for it.