The development partner you call when you've sold something difficult.
Keep the client, strategy and margin.
We handle the WordPress development behind your brand — from one difficult integration to complete technical delivery.
Senior-led. White-label by default. Flexible enough to start with one problem.
The same senior lead owns architecture and review on subcontracted work, so what comes back is something you can defend to your client.
Who talks to whom
Front of house
Your client
Sees your brand, your contract, your invoice
↕ single point of contact
Your agency
Strategy, design, account
You own scope, timeline and the relationship
↓ briefs, files, feedback
Behind the scenes
HOW MUCH Labs
Build, integrations, performance, handover
Already delivered
3Zabun integrations already delivered
Built with both available approaches — direct database synchronization and the Zabun REST API. If a real-estate client lands on your desk, the integration is not new territory.
See the WordPress–Zabun integration work →What you can count on
Senior-led: architecture and estimates sit with a named technical lead
White-label by default — your brand, your client, your invoice
Flexible enough to start with one problem
NDA before you share client information; IP transfers to you on final payment
When agencies call us
Recognisable situations, not a service menu
The design is straightforward. The integration isn't.
We've inherited a WordPress site nobody wants to touch.
The client's launch date moved forward.
We need someone senior, but not another permanent employee.
Our frontend team needs someone to own the backend.
The project is already going wrong and needs stabilising.
The client wants functionality outside our team's usual stack.
HOW MUCH Labs is most useful when the problem is not simply "we need another pair of hands," but "we need someone senior to take ownership of this."
What we take on
Difficult or awkward work that agencies often do not want to staff permanently. A whole build or a single problem — both are normal.
Build
Custom WordPress plugins
Functionality that does not exist off the shelf, written so your client owns it. Useful when the feature is too specific to hire for permanently.
Build
Bespoke themes and Gutenberg
Your designs implemented as a maintainable theme and editor experience, instead of page-builder settings the next developer has to unpick.
Integrate
Third-party API integrations
The design is often straightforward. The other system is not. We own the awkward part: authentication, failure handling and data that does not match the documentation.
Integrate
CRM and property-system integrations
Specialist synchronisation — including Zabun — that most teams do not want to staff year-round, delivered so you can still sell the project.
Modernise
Legacy WordPress and PHP
Inherited code nobody on the internal team wants to own. We read it, name the risk, and modernise it far enough that development can continue.
Migrate
Data migrations and imports
Moving content and structured data onto a cleaner model without losing URLs or breaking what is already live.
Integrate
Scheduled and background sync
Cron, queues and failure handling for data that has to stay current. The kind of work a page builder does not cover.
Rescue
Performance troubleshooting
A launch-date problem that needs a cause, not another plugin. We find what is actually slow and fix that.
Build
Backend-heavy WordPress
Your frontend team can ship the interface. Someone still has to own the data model, business rules and admin tooling behind it.
Rescue
Rescue and takeover projects
A build that is already going wrong. We stabilise it so you can keep the client, without taking on a permanent hire to do it.
Backend
Symfony and PHP backend work
Occasional backend-heavy projects without a permanent Symfony hire. The same senior lead, on a separate page if that is the whole brief.
Decide
Technical discovery and architecture
A written scope and the technical decisions behind it, before you quote the client — so the difficult parts are named early.
We do not compete for your clients' design, strategy, content or advertising work. Development is the whole offer.
Selected work
Delivery snapshots
Much of our agency work is delivered under NDA or white-label arrangements, so some names are intentionally withheld.
Turning CRM property data into a maintainable WordPress experience
Challenge
Property data needed to be synchronized from an external real-estate CRM into WordPress, with structured listings, filters, indexable URLs and lead capture.
Our responsibility
HOW MUCH Labs handled the backend and the WordPress integration layer.
Delivered
- Custom integration
- Custom post types
- ACF-structured data
- Scheduled synchronization
- Property filters
- SEO-friendly listing URLs
- Lead transfer back to the CRM
Outcome
The integration was delivered and deployed. Manual re-entry of property data was replaced with scheduled synchronization.
Delivered as technical implementation. Agency and end-client names withheld.
Moving custom functionality out of the page builder
Challenge
The interface could have stayed in a page builder. The content model, reusable components and later changes could not live there cleanly.
Our responsibility
HOW MUCH Labs implemented the theme and structured content. Design stayed with the agency.
Delivered
- Maintainable theme architecture
- Reusable components
- Structured content
- Custom functionality moved into code
Outcome
Further development no longer depended on page-builder settings. The agency kept the client relationship.
Delivered as a white-label technical partner. Names withheld by agreement.
Taking ownership of backend work the internal team did not want to untangle
Challenge
Missing documentation, plugin and custom-code interactions, and a site that needed to be stabilised before further development was safe.
Our responsibility
HOW MUCH Labs took ownership of the backend investigation, debugging and stabilisation.
Delivered
- Diagnosis of the inherited code
- Targeted fixes
- Refactoring where it reduced risk
- Deployment support
Outcome
The inherited codebase was stabilised sufficiently for continued development.
Delivered as subcontract development. Names withheld by agreement.
How subcontracted delivery works
1
You send the brief
Designs, requirements, or just the problem. We read it properly and come back with questions — usually the ones that would have surfaced halfway through the build.
2
We scope it in writing
A fixed scope, price and delivery date, written in language you can forward to your client with our name removed. Anything we consider risky or underspecified is named here, not discovered later.
3
You quote and confirm
Your client signs with you. You mark up however you like. Our agreement is with your agency only, and we invoice your agency only.
4
We build, with a named lead
A named senior lead owns technical decisions, estimates and review. Progress is visible on a staging site, in whichever channel you prefer. Extra specialists join only when the project needs them.
5
You hand it over
Full source, repository access and documentation transfer to you. If you want us on standby for launch week or ongoing maintenance, we are; if not, you are not tied to us.
Invisible by default
Your client relationship stays protected.
HOW MUCH Labs can work entirely behind your agency. We do not approach your client independently, publish subcontracted work without permission, or turn delivery access into a sales opportunity.
No client contact without your say
We do not email, call or invoice your client. You are the only point of contact unless you explicitly bring us in.
Your brand on everything
Documentation, staging links, commit messages and handover material carry your naming — not ours.
Your NDA, signed first
We will sign your non-disclosure and non-solicitation terms before you share client information. We also offer ours if you would rather start from a template.
Code ownership transfers to you
Full source and IP hand over on final payment. Nothing is licensed back to us and nothing phones home.
No portfolio surprises
We publish nothing about the project — no case study, no screenshot, no client name — without written approval from you.
Named as a partner only if you want
Some agencies prefer to introduce us openly as their development partner. That is available on request, but invisible is the default.
Who is responsible
Senior accountability, not anonymous capacity
Aleksandar Jakovljević — Founder & Technical Lead
Every subcontracted engagement has a named senior lead responsible for technical decisions, estimates, architecture and delivery.
You will not be passed from a sales conversation to an anonymous junior delivery team after signing.
When the project requires it, HOW MUCH Labs adds trusted senior backend, frontend, QA, DevOps, mobile or design specialists around the engagement. The core stays small. One person remains accountable.
You don't need to start with a large project.
Most agency relationships do not need to begin with a complete website rebuild or monthly retainer.
Give us one integration, one problematic feature, one performance issue, or one backlog item your team has not had time to solve.
You will see how we communicate, estimate, document and deliver before deciding whether to involve us further.
Two ways to work with us
The first engagement can be a single problem. Most partners then use a fixed-scope project, and move to reserved capacity once the work is steady.
Model 01
Fixed-scope project
You send the brief and designs. We return a written scope with a fixed price and delivery date before anything is built.
You quote your client whatever you want on top. Our number stays stable so your margin is predictable.
Best for a defined build: a custom theme, a plugin, a migration, one integration.
Model 02
Reserved monthly capacity
You book a set number of development days each month and use them across whichever client projects need them.
Useful when work arrives unpredictably but constantly, or when you need someone on call for launches and maintenance.
Capacity is held for you rather than quoted from scratch each time.
Not a WordPress brief?
The same arrangement covers Symfony — full applications, backend behind your frontend, integrations and version upgrades — under the same terms.
Questions agencies ask first
Not unless you decide to tell them. We work under your brand, in your channels, with your naming. We do not contact your client, publish the project, or list them as our own reference without your written approval.
You do, on final payment. We hand over full source, documentation and repository access so you are never dependent on us to keep the site running or to hand it to another developer later.
Yes, as part of your team if you want a technical voice in the room — introduced however you prefer. Many partners keep us entirely off client calls instead; both work.
From yours. Figma, XD, a PDF or an existing site to match — we build to it and flag anything that will fight WordPress before we start rather than after.
Fixed-scope projects are quoted per project after we read the brief, so you know your cost before you quote your client. Reserved capacity is a monthly rate for a set number of development days. No hourly surprises either way.
Depends on current capacity. Small fixes can usually slot in within a week; a full build is scheduled. Tell us your launch date early and we will be honest about whether it is realistic.
You get one named developer, a written scope, and progress you can see on a staging site throughout. If something is going off-track, you hear it from us before your client hears it from you.
Partner enquiry
Tell us what's difficult.
Send the problem you have already sold, or the one your team has not had time to solve. We will tell you honestly whether we are the right fit.
We are happy to sign your NDA before you share client details.