White-Label Drupal Development

Senior Drupal engineering delivered under your brand. Your client never meets us, the work ships as yours, and you keep the relationship and the margin.

For agencies

What agencies bring us

Agencies lose Drupal work when a project needs depth they cannot staff for, or arrives while the team is already full. We run as your Drupal team, under your process, your brand and your client relationship, so you can take the project and keep the account. We have built on Drupal since 2012, with platforms running for government bodies, universities and enterprises: that is the bench you are borrowing.

  • Drupal 7 and legacy migrations

    Content mapping, module compatibility, redirect preservation and a trial migration before cutover. The same work as our migration service, delivered under your name.

  • Custom module and integration work

    Where a contributed module gets you most of the way and the last part is the reason the project exists.

  • Overflow capacity

    A team that is already committed, and a project that cannot wait for the next slot.

  • Inherited codebases

    A site built by someone unavailable, with no tests and an update backlog. We audit first so the scope is based on what is actually there.

  • Platform builds

    Where one of our ready-made platforms shortens the distance: licensed to you and branded as yours.

Terms

How it stays invisible

White-label only works if it is genuinely white-label. These terms are settled in writing before any work starts.

  • NDA before requirements

    Signed before a codebase, a requirement document or a client name changes hands, not after a proposal has been written on the strength of it. That has been the starting position on every partner engagement since 2012.

  • Not named to your client

    We do not contact your client and we are not named to them. Work delivered under your brand is not published as our case study.

  • Non-solicitation, both ways

    An NDA covers information, not approaching your client or hiring your developer. Non-solicitation of your clients and your staff, and ours, is written into the contract at signing rather than left to trust.

  • Warranty held by you

    On development projects the warranty belongs to your agency, as the party that signs with us: one year by default, up to three. What you promise your own client is yours to set.

  • Source code assigned to you

    Bespoke work ships with full source from day one, to you, and to your client if that is how you contract with them. Our ready-made platforms are licensed rather than sold, and we say which applies before anything starts.

  • You decide who appears

    If you want us on a client call under your brand, that happens. If you want us never to appear, that is the default.

Process

How a white-label engagement runs

The shape is deliberately plain, because the interesting part should be happening on your side of the wall.

    1. Scoping

      You describe the piece of work; we ask the questions that decide its size. Where there is an existing codebase we read the repository first, because a scope written without reading the code is a guess with a number attached.

    2. Access, not onboarding

      We join your tracker, your repository and your branching model. You do not write a process document for us, and we do not ask you to adopt ours.

    3. Named engineers

      You know who is doing the work. If that changes mid-engagement you are told, rather than discovering it in the commit log.

    1. Weekly working software, to you

      Demos go to you, on your schedule, and you decide whether any of it is shown to your client and by whom.

    2. Review gates are yours

      Code follows Drupal coding standards so a reviewer on your side can read it without a handover meeting. Automated test coverage ships with the code rather than being offered as an extra.

    3. Delivery under your name

      The deliverable, the documentation and the commit history are yours. Your client sees your agency.

Handover, and what happens when the work ends

The end of an engagement is the part agencies should ask about first.

Documentation is a deliverable rather than a favour, and it is written for a developer who has never met us, which is the only useful test of whether it is any good. The repository is yours and lives in your account; there is no build step that only runs on our machines, and no deployment that only we can reach.

At offboarding, access is revoked on your side rather than surrendered on ours: you remove us from the tracker, the repository and any environment you granted, and you do not need our cooperation to do it. What we hold afterwards (working copies, credentials, client material covered by the NDA) is covered explicitly by the agreement rather than assumed, and we follow whatever retention and deletion terms you set.

The test of all of this is whether another Drupal team could pick the work up. Standards-compliant code, tests, documentation and a repository you control are what make that true.

Protecting the client relationship you already own

What damages an agency in a subcontracting arrangement is rarely malice. It is an email sent to the wrong person during an incident.

So the communication rules are settled before the work starts, not during the first outage. There is one route in and one route out: your project contact talks to our engineer, and nobody improvises. We do not have your client in an address book. If something goes wrong in production we tell you, with what we know and what we do not, and you decide what your client is told and when, because you are the one who has to say it.

Escalation is agreed in the same conversation: who to reach out of hours, what counts as critical, and what the first response target is. Our published warranty targets are a first response within four hours for critical issues, one business day for high priority and three business days for normal. Those are first-response targets rather than resolution commitments; anything tighter belongs in your agreement and is set per engagement.

We never invoice your client, never appear in their vendor list, and never hold a credential of theirs that you did not issue to us.

What to check before you sign

The questions we would ask a subcontractor, with our answers to each.

  • Can we see the repository during the build? Yes, from the first commit, in your own account. Otherwise you are buying a status report.
  • Who exactly is working on it? Named engineers. If one leaves mid-engagement you are told first, with a handover rather than a substitution.
  • Is non-solicitation in the contract? Yes, covering your clients and your staff, and ours.
  • What do you hold after the engagement ends? Only what your agreement allows, for as long as it allows.
  • Is there public code we can read? Our contributed modules are on drupal.org, with their issue queues.
  • What is the warranty, and what does it exclude? One year by default, up to three, held by your agency, covering defects rather than new features: set out in full here.

Questions

Questions agencies ask first

Will our client know you exist?

Only if you decide they should. The default is that they do not: we work through you, in your systems, and the deliverable ships under your name.

What are your rates?

Set per engagement, because a single module build and a migration programme are not the same arrangement. What we commit to is that the terms are agreed before you commit, never renegotiated once you depend on us.

Who owns the code?

You do, and so does your client if that is how you contract with them. Bespoke work ships with full source from day one. The exception is our ready-made platforms, which are licensed rather than sold, and we say which applies before anything starts.

What if you disappear mid-project?

It is the right question to ask a subcontractor. We have been operating since 2012, the code follows Drupal coding standards with automated test coverage, and documentation is a deliverable, so another team could pick it up. That is the honest answer rather than a promise.

Can you work in our process?

Yes. Your tracker, your branching model, your review gates, your release cadence. Asking you to adopt ours would defeat the point.

How do we start without betting a client on it?

Start with one contained piece of work: a module, an audit, a migration assessment. That is a cheap way to find out whether we are any good before anything important depends on it.

Start with one piece of work

Tell us what is on your plate that you would rather not staff for.