PRODUCT ENGINEERING / CONNECTED BUSINESS SYSTEMS
OmnistuSTUDIO / SERVICESStart a project

Content engineering / Drupal

Drupal development.
Content models, editorial rules and connected experiences.

Custom modules, themes and headless content scope for organisations with many editors, approval steps, languages or sites. Define who can see, change and publish each kind of content before choosing the architecture.

Discuss Drupal requirements โ†—
Contents ยท Drupal

Start with content ownership and editorial work.

Drupal work can include site building, custom modules, a Twig theme, content migration, a multisite setup or a decoupled backend. Universities, public bodies, publishers, membership organisations and multi-brand teams can have different permissions and publishing needs. Map the content, editors, audiences, approval transitions and external systems before selecting modules.

Use a Composer-managed project, reviewed configuration exports and a protected staging environment. Inventory core, contributed and custom code, security-advisory coverage, theme dependencies and external accounts. Keep environment-specific secrets out of ordinary source and configuration exports. A platform label does not establish accessibility, security certification or capacity.

A small editorial team can still have complex needs, and many pages can have simple workflows. Compare CMS options through representative tasks rather than a page-count rule or an assumption that Drupal is always the enterprise choice.

Source access does not settle every right or responsibility.

Agree the Composer project, custom modules/theme, configuration exports, repository history, API documentation, deployment scripts, sanitised sample data and operating guide to be delivered. Distinguish custom-code rights from core/contributed licences, purchased assets, content rights and external services.

Record confidentiality, white-label use, source access, account control, maintenance, support, exit and receiving-team responsibilities in writing. Source delivery does not guarantee immediate independence or transfer every third-party right. Prove the handover through setup, deployment and recovery rather than a repository link alone.

Name hosting, domain, identity-provider and integration owners. Transfer secrets through an approved secure route, not a source archive or ordinary document.

Compare content, governance and operating constraints.

Compare Drupal, WordPress, Strapi and Contentful using the same content model, editor tasks, permissions, approval workflow, language needs, API clients and operating team. Do not assume one platform is cheaper or faster because a site has fewer editors.

An existing WordPress workflow can prompt a WordPress review. A JavaScript-oriented CMS or managed content platform can suit a different receiving team. The relevant question is whether editors and developers can demonstrate the required work with clear ownership and an acceptable maintenance burden.

Seven decisions before a Drupal engagement.

What does custom development cover?

Site building configures content types, fields, taxonomies, Views, menus and roles. Custom development adds services, plugins, hooks, forms, event subscribers and integrations where configuration or supported contributed modules do not meet the requirement. Keep that distinction visible in scope and acceptance.

Plan moderation states and transition permissions, interface/content/configuration translation, accessible components and SSO/CRM/search/commerce connections. Drupal core and contributed capabilities need to be installed, configured and tested; their availability is not evidence that a delivered site implements them.

What does Drupal 7 end of life mean?

Drupal.org records Drupal 7 end of life on 5 January 2025. Treat a remaining legacy site as a migration and security-risk review, not as supported merely because it still responds. Check any paid extended-support scope and the actual core/modules/runtime it covers.

Moving from Drupal 7 to modern Drupal involves rebuilding or replacing incompatible code/themes and migrating content/configuration as appropriate. Inventory fields, users, taxonomy, files, aliases, relationships, custom data and workflow behaviour. Rehearse mappings and reconciliation instead of promising a complete automatic transfer or preserved search rankings.

Which CMS should be chosen?

Ask editors to model, create, review, translate, publish, search and retire representative content. Ask developers to demonstrate access, API, deployment and recovery. Compare the same evidence across Drupal, WordPress and headless options. A platform preference, editor count or generic enterprise claim is not a fit assessment.

Can Drupal work with a commerce platform?

Drupal Commerce is a separately assessed commerce approach with its own modules, merchant/provider eligibility and operating requirements. Alternatively, Drupal can supply content while BigCommerce, Shopify or another system owns catalogue, cart and checkout. Define the boundary rather than letting both systems overwrite product data.

These are diagnostic paths, not a claim that a stale page always means one particular webhook defect. See the qualified BigCommerce and Shopify scope guides when those platforms are involved.

What does operation require after launch?

Name owners for hosting, core/contributed/custom updates, runtime, database, cache, search, cron, backups, incidents and receiving-team documentation. Managed hosting can provide environments and workflows but does not remove every application or editorial responsibility.

Monitor current core and applicable contributed-module advisories. Security coverage is not identical for all contributed releases, and custom code requires its own review. Prioritise patches according to advisory impact and exposure with a tested release route, not a universal patch-within-days slogan or an assumed maintenance window.

What drives price and delivery?

Content types, roles/transitions, languages, sites, migration/cleanup, custom code, SSO/CRM/search/commerce and a separate headless front end affect scope. Separate implementation from hosting, licences/services, updates and ongoing work. Obtain a current itemised written quote and milestones; source sample prices, durations and retainer terms are not present offers.

Freelancer, in-house team or a company?

Match skills, continuity and accountability to the work. A contained module fix and a multi-site migration with editorial governance need different coordination. Name site-building, PHP, theming/front-end, QA and operations reviewers and who receives an incident after handover.

Request attributable relevant work, configuration/dependency inventory, a reproducible build and an upgrade/restore rehearsal. Agree confidentiality, custom rights and support in writing. A team size, certification or company label does not prove the required workflow.

Services, access rules and cache dependencies.

Feature modules and configuration

Keep business services separate from presentation and thin hook/controller adapters where practical. Use dependency injection and supported entity/plugin/service boundaries rather than shared globals or hidden rules in theme preprocessing. Describe which module owns an entity, field, configuration or integration effect.

Export and review configuration through the supported management workflow; distinguish configuration from content and environment-specific settings. Test installation, schema/configuration updates, dependencies and removal. Do not erase business data or configuration ownership accidentally during uninstall. Unit, kernel and functional tests cover different risks and should match the feature.

The department-policy access snippet is not complete authorisation

The original example uses hook_node_access to deny updates when a policy node's department is absent from the user's department references. Drupal's AccessResult::forbiddenIf returns forbidden when the condition is true and neutral when false. Matching the department therefore does not itself grant update access; other permission and access rules still apply.

Define the intended grant/deny policy, bypass roles, anonymous accounts, missing fields/entities, multiple references and revision/translation behaviour. Validate field assumptions and avoid turning an unexpected empty value into an unintended allow. Review actual route/entity/field access for forms, JSON:API and custom endpoints.

Cache metadata must reflect both variation and invalidation. cachePerUser adds a user context; the node/user dependencies can invalidate results when relevant data changes. That does not prove the entire access chain is correct. Test allowed, denied and neutral results for multiple accounts, warm caches and department changes. No partial snippet is presented as a complete secure policy.

Contexts, tags and max-age solve different problems

Drupal cache contexts describe request-dependent variation, such as user, permissions, language or route. Cache tags track data dependencies for invalidation; max-age expresses time dependency. Declare the actual dependencies and allow metadata to propagate through rendering and access checks. A global cache clear can hide an invalidation defect rather than fix it.

Official documentation warns Internal Page Cache assumes anonymous pages are identical and does not apply contexts as a way to vary those cached anonymous responses. Review that boundary before adding anonymous personalisation. Test authenticated pages, previews, permissions and private files rather than caching everything behind a reverse proxy.

Measure production-like settings with representative content and traffic, including uncached and invalidation paths. Keep debug/profiling tools appropriately restricted. Redis, Varnish or a CDN are separately selected options, not a preconfigured performance or privacy guarantee.

Headless delivery keeps access and preview work

Core JSON:API reuses entity/field access and validation rather than adding a separate security layer. Its documented default read-only mode reduces write exposure. Audit exposed entity bundles/fields, stable-module/security coverage, authentication, CORS and least-privilege roles before enabling writes. A role permission alone does not justify exposing every resource.

A React, Next.js, Flutter or React Native client needs its own rendering, SEO, preview, session and deployment design. Verify drafts, translations, media/private files, related resources and invalidation. GraphQL is a separate contributed-module choice. Do not place privileged credentials in distributed front-end code or assume core APIs constitute a finished mobile backend.

Shared code does not mean shared content or one deployment step.

Drupal multisite can share a codebase while sites retain separate databases/settings and their own configuration. Plan domains, files, secrets, site selection and per-site dependencies. The inspected setup guide explicitly describes itself as work in progress, so its example server configuration is not a production recipe.

A shared content hub, syndication or single sign-on requires explicit integration architecture. Entity references in one database and a Group module do not automatically share content across separate multisite databases. Choose a single site with sections/groups or a federation only after comparing governance, deployment and data boundaries.

Three engagement shapes with distinct obligations.

Agree milestones, review cadence, billing, cancellation and support. No guaranteed sprint output, fixed team size, first-commit deadline, included support window or automatic production change is implied.

Six acceptance areas before CMS handover.

Test keyboard, screen-reader and other agreed accessibility requirements with representative authored content. Security or accessibility checks are evidence with scope, not blanket OWASP, WCAG, privacy or public-sector certification. Production/DNS changes and external tracking activation require their own authority.

Select a stack for the content and receiving team.

An option inventory, not an installed bundle or a verified hosting entitlement.

Verify support for every core/contributed/custom component and hosting service. A current release schedule can change; use it to select and maintain the actual version instead of calling an old major current indefinitely.

Rebuild legacy behaviour and reconcile the content graph.

Audit the source core/modules/theme, support/security status, direct changes, configuration stored only in the live database and disabled caches hiding bugs. Inventory entities/fields, users/roles, taxonomy, files, aliases, redirects, revisions/translations, relationships, custom tables and integrations.

For Drupal 7, map useful content and configuration through supported migration tooling and replace or rebuild incompatible modules/themes. The Migrate API is a framework for transformation, not proof every legacy behaviour transfers. Rehearse imports, updates, rollback and final/delta sync with representative relationships and exceptions, not just matching counts.

Review author/owner assignments, private files, passwords/SSO identifiers, moderation states, translated references and old URLs. Test permissions and API exposure after migration. Keep sensitive records out of ordinary fixtures and logs. Agree editor freeze, cutover, supported rollback and post-release reconciliation without a search-ranking or complete-data guarantee.

Current Drupal.org documentation dates Drupal 7 end of life and maintains support schedules for later versions. Re-check the exact destination and contributed dependencies before a real migration and select a target from actual support, module and hosting compatibility.

From editorial brief to an operated content service.

Content readiness, identity/provider access, review and external approvals can affect delivery. Agree milestones and change control in writing; no fixed duration, same-day agreement, first-commit promise or automatic live deployment is offered.

What changes the Drupal estimate?

Separate one-time implementation from hosting, licences/services, maintenance and feature capacity. Obtain a current itemised written quote with assumptions and exclusions; source sample amounts, project ranges, durations and retainer terms are not treated as offers.

An illustrative public-information consolidation.

Consider a public organisation consolidating fragmented websites and citizen-service content. This is a requirements scenario, not a Dutch municipality client case, verified compliance result, adoption figure or delivery outcome.

The source contains conflicting consolidation descriptions and mixes illustrative framing with claimed outcomes. No site count, original-system assumption, duration, adoption, publishing-time improvement or certification is adopted as proof. The useful requirement is a documented source inventory and tested governance/access/migration design.

Drupal delivery review and handover.

Agree the implementation boundary, deliverables and acceptance checks in the project scope. Include the source and configuration to be handed over, third-party dependencies, account ownership and the receiving owner's installation and operating walkthrough. Review the selected work at the agreed milestones, with unresolved items recorded before release.

The delivery review can cover a reproducible Composer build, reviewed configuration, access/moderation tests, cache/invalidation traces, migration reconciliation, measured workload and upgrade/restore handover. Confirm contracting identity, current credentials if claimed, commercial terms and support/source obligations directly. No agency counts, ratings, named testimonials or guarantees are reproduced as verified proof.

Turn sector names into editorial responsibilities.

Questions to settle before Drupal work.

Can an inherited site be taken over?

Audit core/module support, custom entity use, configuration/dependencies, caches, accounts and backups. Rehearse prioritised fixes or legacy migration on staging, then agree scope and evidence before changing production.

What administration and source are included?

Define content lists, editing forms, role menus, moderation and translation tasks. Agree code/history, Composer/configuration, licences, sanitised data, API notes and setup/recovery documentation. Source access is not a universal rights or immediate-maintainability guarantee.

Is Drupal too much for a marketing site?

Compare actual content/governance and receiving-team tasks. WordPress or a headless service may fit, but editor/page counts alone do not prove cost, ease or suitability.

Can the backend serve a website and mobile apps?

JSON:API, selected GraphQL or custom endpoints need access, fields, preview, caching and client compatibility checks. Keep write exposure minimal and test entity/field access. A mobile app and its store submission are separate deliverables, not automatic features of a Drupal website.

How is a stale commerce value investigated?

Trace the authoritative upstream value, Drupal stored copy, rendered/API result, cache metadata and delivery/worker logs. Check authentication, event timing, retries, limits and reconciliation. Do not assume one symptom uniquely identifies a cache or webhook defect.

What happens after handover?

Agree advisory response, patching, updates, monitoring, defects, support, contact hours and escalation in writing. Continuing capacity, contracting model and confidentiality need their own terms. No current quote, response-time promise, included support period or guaranteed weekly output is verified here.

Platform references used for technical checks.

Official documentation checked on 17 November 2026. Verify exact release, contributed-module support, hosting and provider terms before implementation. Older examples and planned release windows are not a production recipe or guarantee.

Bring the content rule or editorial task that needs to change.

Describe the content, editors, audiences, languages/sites and legacy platform. Keep access, moderation, integration ownership and receiving-team responsibilities visible, then agree scope and evidence before committing to implementation.

Discuss your Drupal scope โ†—