About this service
Build scalable, maintainable software with our experienced engineering teams. We deliver high-quality code and best practices that help your product succeed.
Go to service
Brownfield Development
The engineers who thrive in existing software
Most software work is brownfield. Most agencies pretend it isn't.
Brownfield development means working with existing software — live applications with real users, real data, and years of decisions baked into the code. It's harder than starting from scratch, and most teams underestimate it.
We built our entire practice around it. Our engineers don't get frustrated by legacy code — they get curious. They map it, understand it, and improve it safely.
The result: faster delivery, lower risk, and a codebase your team is proud of rather than afraid of.
OUR PHILOSOPHY
“Even the most outdated legacy code delivers value and deserves to be cherished. In 90% of cases, upgrading and improving the existing product gradually is better than starting over.”
— madewithlove, after 15+ years of brownfield work
How we approach brownfield work
Brownfield development is a discipline, not just a mindset. These five principles guide every engagement — from the first audit to the last pull request.
01
Understand before you touch
We map the system before writing a line. What exists, what it does, what breaks if you move it. Most problems come from teams who skipped this step.
02
Incremental, not disruptive
We improve in small, safe steps — feature by feature, module by module. Each change ships value and leaves the system more stable than we found it.
03
Tests before refactors
We add tests around existing behaviour before changing it. Not as overhead — as the safety net that lets you move fast without breaking things.
04
Preserve the business logic
Years of edge cases and customer-specific rules are baked into the code. We understand what to keep, what to clean, and what to never throw away.
05
Mentor your team in context
Brownfield work is a skill. We don't just fix your codebase — we show your team how to navigate complexity, manage debt, and build sustainably going forward.
FROM 150+ SAAS AUDITS
85% ship without automated testing
Manual QA dominates at every stage, seed to M&A.
Why QA becomes the bottleneckFROM 150+ SAAS AUDITS
40% of codebases have secrets in git
The finding investors react to hardest.
The security hole nobody talks aboutWhat brownfield work looks like in practice
Legacy PHP and monolith modernisation
PHP 5 on a shared host, a Laravel app that's grown into a monolith, Symfony modules nobody understands. We've seen it all and know how to move it forward safely.
Incremental rewrites and strangler fig
When a full rewrite isn't feasible, we apply the strangler fig pattern — replacing pieces of the old system with new, clean code while everything stays live.
Technical debt reduction
We identify which debt is costing you the most right now, build a prioritised plan, and begin paying it down — without freezing feature development.
Undocumented system archaeology
No documentation, departed original developers, no tests. We reconstruct the system map, document as we go, and restore confidence in the codebase.
Post-acquisition integration
Acquired a product with a different tech stack? We assess what you've got, plan the integration path, and execute without derailing either team.
Performance and infrastructure modernisation
Slow queries, memory leaks, a server that can't handle growth. We diagnose and fix the bottlenecks, then modernise the infrastructure around them.
THE SAAS SHOW
Technical debt starts outside the code — and other SaaS lessons
Why teams choose us for brownfield
We chose brownfield on purpose
Most agencies want greenfield projects. We built our practice around the opposite. Existing code, real complexity, live users — that's where we do our best work.
90% of cases don't need a rewrite
We push back hard on the rewrite impulse. A rewrite takes years, burns budget, and often produces the same problems. Incremental improvement is safer and faster in almost every case.
Senior engineers, not juniors
Brownfield work is not a training ground. We send senior and staff engineers who have navigated legacy systems before and know when to refactor versus when to leave well enough alone.
We've audited over 180 SaaS codebases
Our due diligence and audit work means we've diagnosed more existing codebases than almost anyone. We know what healthy looks like, and what the path from unhealthy to healthy requires.
We embed, not consult
We work inside your team, in your codebase, alongside your developers. Not a report handed over a wall — real, hands-on progress every sprint.
We don't abandon the humans in the room
Code debt is often team debt. We pay attention to the people — knowledge silos, missing documentation, unclear ownership — and help fix those alongside the technical work.
We help our clients succeed
You will not see companies like Amazon among our past clients. You will, however, see the names that will soon rock the SaaS world because we helped them predict risks and avoid failure.
“We couldn’t have done it without madewithlove and now realize we wouldn’t want to. I have worked with many development shops over the years and can say with 100% confidence that they truly are the best in the business.”
David Macfarlan
CEO, GearJot
“Madewithlove came in when we needed to build a robust web environment with a tight budget and schedule as a start-up. They understood this, took the lead and managed to get us up and running in no time. They also made some important technical choices that allow us to scale our…” Read more
Julien Yee
Co-Founder, JUCE
“Madewithlove helped us by providing a critical eye for our situation then got their hands dirty, got involved to fix problems, to put us on a better path.”
Dorian de Broqueville
General Manager, Izix
Our writing on legacy code and technical debt
- →Embracing brownfield projects: legacy code in SaaS
- →Understanding and managing technical debt and legacy code: a guide for founders
- →A framework to deal with technical debt
- →How to modernise a PHP project without a full rewrite
- →Legacy vs technical debt: how investors can spot hidden risks
- →Technical debt lost its excuse
- →How to manage technical debt as part of your agile process
The case against the rewrite
The rewrite is the most seductive solution in software. The code is messy, the team is slow, and starting fresh feels like the only answer.
It rarely is. Rewrites routinely take three times as long as planned, cost twice the budget, and reproduce the exact problems that motivated them in the first place — because the problems were never just in the code.
We will tell you the truth about your situation. Sometimes a rewrite is the right call. Most of the time, it isn't.
Rewrites freeze delivery
While the rewrite is in progress, the old system still needs maintenance. Two codebases, double the workload, and nothing ships to users for months.
Business logic gets lost
Years of edge cases, compliance rules, and customer-specific behaviour live in the old code. Rewrites discard this institutional knowledge — and discover it's missing when users complain.
The mess follows you
Bad architecture is usually caused by bad habits and unclear ownership, not bad technology. A new stack with the same team and the same pressures produces the same result.
Got a codebase that needs love?
Tell us about your software. We'll give you an honest view of what it needs and how we can help — no commitment required.
Frequently asked questions about brownfield development
Brownfield development means working on existing software — improving, evolving, and modernising applications that are already live with real users, rather than building from scratch (greenfield). It requires understanding legacy code, managing technical debt, and making changes safely without disrupting the business. Most software work in the real world is brownfield.
Greenfield development starts with a blank slate — a new product, no legacy constraints. Brownfield development works within an existing codebase that has history, technical decisions made years ago, and users who depend on it today. Brownfield is harder because you must understand what exists before you can safely change it. It requires different skills, more experience, and a different mindset than greenfield work.
In 90% of cases, incremental improvement is better than a rewrite. Rewrites take far longer than estimated, often reproduce the original problems, and leave the business in limbo for years. Incremental modernisation is safer, cheaper, and delivers value continuously rather than at the end of a long, risky project. We will tell you honestly if your situation is the 10% exception.
We work on legacy PHP and Python backends, monolith modernisation, undocumented systems, post-acquisition integrations, infrastructure upgrades, and technical debt reduction programmes. If your software is live, has users, and needs to be better — we can help.
We start by mapping the system — not just the code, but the business logic embedded in it, the implicit rules, the edge cases. We interview your team, run our audit framework, and build a picture of what exists before proposing any changes. Understanding comes before touching.
Yes — that's the model. We embed with your team rather than working in isolation. We review code together, pair on the complex parts, and help your engineers build the skills to handle this kind of work themselves going forward. We are not a black box.
Brownfield engagements typically run on a time-and-materials basis with a scoped plan. We don't offer fixed-price brownfield work because the complexity of existing codebases is too variable. We start with an audit or discovery phase, then propose a phased plan with clear milestones and expected outcomes.
PHP (Laravel, Symfony, legacy), Python, JavaScript and TypeScript (React, Node, Vue), Ruby, and more. We are language-agnostic in that the principles of brownfield modernisation apply regardless of stack — but we have the deepest bench in PHP, TypeScript, and Python.