I'm going to tell you something the agency on your current project doesn't want you to know.
The senior engineers who pitched your project are not building it.
I've worked inside agencies. I've cleaned up their messes from the outside. I've reviewed their code, met their teams, and talked to the founders who hired them. The pattern is remarkably consistent across London, Manchester, and any other city where software agencies operate.
You get sold by a partner or principal engineer—someone with 15 years of experience who speaks confidently about architecture, asks the right discovery questions, and prices the project with authority. You sign the contract. The project starts. And the actual code is written by a team of juniors two years out of a bootcamp, supervised by a mid-level PM who's simultaneously managing four other projects.
The Agency Math
A London agency charges you £100-150 per hour. Their senior engineer costs them £110K per year in salary—roughly £55/hour billable. Their junior developer costs £42K—roughly £21/hour billable. The margin on the junior billing at senior rates is enormous.
Agency business model: pitch with seniors, deliver with juniors, charge senior rates throughout. The client never sees the cost structure. They see sprint velocity numbers and a Jira board with green checkmarks.
This isn't unique to small agencies. I've seen this at shops with 80 people and impressive client logos. The principals who built those logos are now in sales and account management. The people building your product are the ones they're currently training.
How to Know If It's Happening to You
Ask to see your team's CVs. Not the agency overview. The specific people writing your code right now. Request a video call with the lead developer, not the account manager. Ask them to walk you through a recent technical decision—why they chose a particular approach, what alternatives they considered, what trade-offs they made.
If the "technical lead" struggles to answer that question without consulting notes or deferring to someone else, that's your answer.
Other signals: sprint velocity that drops predictably after the initial delivery. Bugs that cluster in specific areas of the codebase, suggesting one inexperienced developer owns them. Estimates that are wildly inaccurate in both directions. Architecture that solves the original requirements literally but lacks any consideration for maintenance or extension.
I was brought in to review a codebase that an agency had charged £320K to build. It was a relatively straightforward SaaS dashboard with a Next.js frontend and a Node.js API. What I found: no tests of any kind, a 4,000-line React component that owned both data fetching and rendering logic, API endpoints that constructed SQL strings directly from user input (a textbook SQL injection vulnerability), and hardcoded credentials in the repository history.
The agency had junior developers. The juniors didn't know better. Nobody with the experience to catch these patterns was reviewing their code.
The Offshore Escalation
Many UK agencies have a secondary cost optimisation they don't advertise: offshore delivery teams. The account is managed in London. The code is written in Kyiv, Łódź, or Mumbai. This isn't inherently bad—I work with excellent engineers across Europe—but it introduces communication overhead that junior developers can't absorb.
Timezone misalignment means blockers take 24 hours to resolve. Requirements get misinterpreted in ways that aren't surfaced until demo day. Code review, if it happens at all, is asynchronous and shallow.
The math: the offshore junior bills at £20-25/hour. The agency charges you £80-100/hour. The margin is the highest in their entire business model. The quality is the lowest.
What Good Actually Looks Like
I'm not anti-agency as a concept. I run one. But the model I believe in is: the person who sold the project builds the project. You talk to the engineer. The engineer talks to you. There's no PM layer insulating you from the people writing your code.
This model can't scale to 50 people easily. That's a feature, not a bug. Expertise doesn't scale linearly. A 6-person team of genuinely senior engineers will consistently outperform a 25-person team where 5 are senior and 20 are not.
Before you sign any agency contract, ask: - Who specifically will be writing the code? Get names. - What is their experience level and what have they built before? - What does your escalation path look like when technical decisions need to be made? - Will you get access to the version control repository from day one? - What does your code review process look like and who conducts the reviews?
The answers to these questions will tell you more about what you're actually buying than any case study or client logo.
The £500K Lesson
The most expensive engagement I've been involved in was a rescue project: £500K spent over 18 months, a product that didn't work, and a CTO who had to explain to their board how this had happened.
The agency was well-regarded. The website was impressive. The sales process was professional. The delivery was catastrophic.
The CTO had never asked who specifically would be building the product. They had assumed that a contract with a senior-looking agency meant senior people would be doing the work. They were wrong.
That's not an unusual story. It's the story that the agency model was designed to make invisible.
Ask the question. Before you sign anything, ask the question.