Drupal built to survive the developer after you.
Most Drupal problems we are asked to fix are not bugs. They are decisions. A content type that should have been three. A contrib module patched in place and never documented. Business logic buried in a preprocess function where nobody will ever look for it.
We have been building Drupal since version 6 and have watched what happens to those decisions four years later. So we build the boring way: core standards, configuration in code, custom modules that a Drupal developer who has never met us can read and extend.
- Custom modules and plugins
- Twig themes and design systems
- Multisite and multilingual
- Views, entities and workflows
- Headless front ends
- Apache Solr search
- Redis and Varnish caching
- CI/CD on Acquia and Pantheon
- Security patching
- Performance and Core Web Vitals
Six areas, and what each one actually involves.
Drupal is broad enough that "Drupal developer" says almost nothing. This is the work we are hired for.
Custom modules
Bespoke functionality written to core standards, with proper dependency injection, update hooks and configuration schema so it upgrades cleanly.
- Custom entities, fields and field formatters
- Workflow, moderation and editorial tooling
- Queue and cron based background processing
- Update hooks so deployments are repeatable
Theming and front end
Twig themes built from a design system rather than a single mockup, so the site still looks right when an editor builds a page nobody designed.
- Twig templates and component libraries
- Layout Builder and paragraph based editing
- Accessibility to WCAG AA where required
- Headless front ends in React or Vue
Multisite and multilingual
One codebase serving many sites, or one site serving many languages, without the maintenance burden multiplying alongside.
- Shared codebase with per-site configuration
- Config split for environment differences
- Translation workflow for content and interface
- Domain and language negotiation
Integrations
Drupal rarely lives alone. Most enterprise builds spend as much effort on what Drupal talks to as on Drupal itself.
- REST, JSON:API and GraphQL endpoints
- CRM, marketing automation and DAM connections
- Single sign-on with SAML or OAuth
- Scheduled sync jobs with proper failure handling
Search and performance
A large Drupal site is fast or slow depending on decisions made in the data model, not on how much hardware it runs on.
- Apache Solr with facets and tuned relevance
- Redis object cache and Varnish page cache
- Query and index analysis on slow pages
- Core Web Vitals and front-end budgets
Hosting and DevOps
The build is only half of it. Repeatable deployment is what stops a good site degrading over the following two years.
- CI/CD with Composer, Drush and automated checks
- Acquia Cloud, Pantheon and AWS
- Environment parity with DDEV locally
- Zero-downtime release process
Drupal is not always the answer.
We would rather lose a Drupal project than deliver one that should have been something else. This is roughly how we advise.
Drupal is a strong fit when
- Content structure is complex and relationships matter
- Editorial workflow needs roles, review and permissions
- Multiple sites or languages share one codebase
- Integrations with internal systems are central
- The organisation will still own this in five years
Drupal is usually the wrong fit when
- It is a brochure site of a dozen pages
- The team has no technical support and never will
- The requirement is really a bespoke application
- A store is the whole product and Shopify would do it
- Budget covers a build but not the years after it
The unglamorous parts that decide how it ages.
Standards enforced by tooling
PHPCS with Drupal and DrupalPractice rules, PHPStan for static analysis, and a pull request template that requires the checks to pass before review.
Configuration in code
All configuration exported and version controlled, with config split where environments legitimately differ. Nothing important lives only in a database somebody has to remember to copy.
Composer and Drush all the way
Dependencies through Composer, patches declared in composer.json rather than applied by hand, and deployment through Drush so the same commands run everywhere.
Documentation for the next developer
A README that explains the architecture and the decisions, not just the install steps. Written for somebody who has never spoken to us, because eventually that is who reads it.
What clients ask about Drupal work.
Which Drupal versions do you work with?
Do you build custom modules or use contrib?
Can you do headless or decoupled Drupal?
Do you follow Drupal coding standards?
How do you handle configuration management?
Can you work with our existing Drupal team?
Which hosting platforms do you work with?
Do you handle Drupal security updates?
Can you improve the performance of an existing Drupal site?
Do you work white-label for agencies on Drupal projects?
Tell us about the Drupal build.
Send the repository, the brief, or a description of what is not working. Within one working day you get a reply from the engineer who would run it.
Before anything is signed, you get a written technical assessment: the real scope, where the risk sits, what we would build differently and why, and a fixed price against it. It costs nothing and it is yours to keep either way.