13 Aug 2026
Drupal.org aggregator
Talking Drupal: Talking Drupal #565 - That Geerling Guy
Today we are talking about Open Source sustainability, becoming your own content creation machine, and how drupal influenced some of that with guest Jeff Geerling. We'll also cover AI Metering as our module of the week.
For show notes visit: https://www.talkingDrupal.com/565
Topics
- Jeff's Timekeeping Icebreaker
- Jeff's Drupal Origin Story
- From Drupal to Hardware Tinkering
- Staying Motivated on YouTube
- What Conferences Are Really About
- DrupalCon Memories and Community
- Why Jeff Moved to Hugo
- PSA Tornado Warning Detour
- Keeping Up with Drupal CMS
- PHP Perception Shift
- Fast Drupal Setup
- COVID Streaming Boom
- Picking Video Projects
- Decommissioning Builds
- YouTube Algorithm Risk
- Vintage Time Server
- Creator Starter Tips
- Supporting Maintainers
- Books and Crohns
- Local Control Trends
- AI Workflow Boundaries
- Timing Obsession
- Kind Drupal Culture
Guests
Jeff Geerling - jeffgeerling.com geerlingguy
Hosts
Nic Laflin - nLighteneddevelopment.com nicxvan Mike Anello - drupaleasy.com ultimike JD Flynn - dorficus
MOTW Correspondent
Mike Anello - drupaleasy.com ultimike
- Brief description:
- AI Metering module - helps keep track of your users' AI token usage on the site. Includes cost estimation, token limits, and local LLM fallback options.
- Module name/project name:
- Brief history
- How old: created in June 1 2026 by Jérôme Tchania (codeitwisely)
- Versions available: 1.0.1
- Maintainership
- Actively maintained - yes
- Co-maintained by Carlos Ospina (camoa)
- Security coverage - yes
- Test coverage - yes
- Documentation - yes
- Number of open issues: 9 open issues, 4 of which are bugs against the current branch
- Usage stats:
- Sites: 78
- Module features and usage
- Obtains token costs for all modules from LiteLLM
- Can be configured to send email when the token limit is being approached.
- Per user and per role reports.
- LLM fallback to Ollama
13 Aug 2026 6:00pm GMT
The Drop Times: Tiffany Farriss Says Public-Sector Budgets Should Fund Open Source Maintenance
Open-source software still depends on infrastructure and human maintenance that carry real costs. Farriss argues that institutions should plan for those costs before contracts are awarded.
13 Aug 2026 3:13pm GMT
Replatform Radar: Drupal to Headless: Taxonomy and Media Reference Traps
The most dangerous moment in a Drupal-to-headless migration is the one where everything looks fine. The content exported. The article titles are all there. Then an editor opens a launch-ready page and half the images are missing, the "related articles" block is pointing at a press release from 2019, and one product's category is now, somehow, a staff bio. Nothing errored. Nothing turned red. The references just quietly stopped meaning what they used to mean. That is the trap, and it lives in taxonomy, media, and entity references specifically because Drupal stitches your content together with numbers instead of names. Drupal is a house where everything is labeled by drawer, not by name Picture a house where nobody wrote what anything is. Instead, every object has a little tag: see drawer 47 . The cookbook says "pairs with drawer 112." The remote says "belongs to shelf 9." It works…
Read the rest at Replatform Radar
13 Aug 2026 2:00pm GMT
Tag1 Insights: Drupal Workspaces FAQ
Traditional content staging servers have had their day. At DrupalCon Chicago 2026, Tag1's Peta Hoyes and Ray Stuart (presenting for Fabian Franz) made that case and showed exactly what replaces them. Their session, Workspaces is Revolutionizing Drupal Core: Unlock True Enterprise Content Management in Drupal, covered the core architecture, live demos, and a Q&A with the room.
We have expanded and organized the questions from that session into a standalone reference on how Workspaces works for enterprise content teams.
Getting Started: What Workspaces Is and How to Turn It On
Q. What is Workspaces?
A. Workspaces is enterprise content staging built into Drupal core. It lets a privileged user preview a large set of changes exactly as a site visitor will see them, then publish the whole set at the click of a button. Instead of maintaining a separate staging site, each workspace is an isolated set of staged changes that layers on top of your live site. You stage, collaborate, and publish without touching production until you are ready.
Workspaces has been stable in Drupal core since version 10.3 (June 2024) and ships with every Drupal 11 installation. It is no longer experimental. It is core infrastructure, and it is free and open source.
Q. How do you get started?
A. Core Workspaces turns on with a single command that most Drupal teams already know:
drush en workspaces
For enterprise use, you also want Workspaces Extra (WSE), which installs the same way most contributed modules do:
composer require drupal/wse
That is a low barrier to entry for enterprise capability out of the box.
Q. What does WSE (Workspaces Extra) add on top of core?
A. If core workspaces are content branches, WSE is closer to the full deployment pipeline you already have for code. WSE adds scheduled publishing, preview links for external stakeholders, rollback of an entire published workspace, access control, menu staging, task monitoring, and the ability to move content between workspaces when needed. WSE Config stages configuration changes alongside content, and WSE Theme lets you preview an entirely different theme staged in a workspace.
Q. I already know git. How should I think about Workspaces?
A. If you understand feature branches, you already understand Workspaces. The mental model maps almost exactly:
- Your Drupal site is the repository.
- A workspace is a branch.
- Live is the main branch.
- Saving content is a commit.
- Previewing a workspace is your working copy.
- Publishing is a merge.
The workflow is the same one developers take for granted: create a branch for your campaign, make your changes, preview the complete state, get approval, then publish. Content teams simply have not had this tooling until now. As the session put it, if your dev team would not ship code without branches, why would your content team ship content without workspaces?
The Core Problem: Why Enterprise Teams Still Struggle with Content Management
Q. What do we mean by true enterprise content management?
A. For a CMS to truly meet enterprise requirements, it needs to provide tools for both creating content and managing the end-to-end governance of that content. Content governance covers everything from procedures to technology that a complex organization needs to make sure its content meets its standards for brand, legal compliance, and accessibility. There can be a lot of content stakeholders with diverse concerns. Strong content governance is what stops all of that from devolving into chaos.
Drupal has been working toward this in core for a long time: granular user roles, workflows, content moderation in Drupal 8. With Workspaces in core, Drupal has closed another major governance gap. Content staging and review in the CMS.
Q. Why is content staging and review in context more important than ever?
Modern enterprise websites are composable. Content comes from multiple systems, dynamically laid out in the CMS, with edits and updates automatically propagating across the site. The governance of large-scale changes (adding new products, migrating a department, launching a campaign) needs to happen in the context of the overall site, with all the pieces of the puzzle present. Until Workspaces, Drupal hasn't had a clean solution for that.
Q. What about the impact on the people who need to manage content?
A. External staging sites mean content managers work in two or more places. And what most content managers do not love is remembering which autogenerated subdomain from a git branch ID is the one they are supposed to be updating. Workspaces keeps everything inside a single Drupal installation.
The Reality of Modern Drupal: Complexity Behind the Scenes
Q. What happens when you need to stage more than one set of updates at a time?
A. More staging usually means more problems. With traditional staging servers, each parallel workstream typically means another environment, another subdomain, another database sync, and another deployment pipeline to track. Workspaces eliminates that. Each workspace is isolated, teams can work in parallel, and there is no artificial limit on concurrent campaigns or content initiatives. Tag1 has tested workspaces with more than a thousand entities changed in a single workspace.
Q. If changes are happening on live while I work in a workspace, can I pull those changes in?
A. Think of a workspace as a shallow copy. Only the changes you explicitly make are tracked in the workspace. If someone modifies different content directly on live, those changes are not in your workspace and will not be overridden when you publish. Your workspace only ever contains what you put there. The one edge case is the same entity being modified in both places, which Workspaces intentionally prevents (see the collaboration section below).
Governance and Control: Who Sees What, and When?
Q. How do you deal with permissions for users who should not see work happening in workspaces?
A. Each workspace is isolated with granular permissions. Design, content, legal, and translation teams can work in parallel workspaces without visibility into each other's work unless it is deliberately shared.
Q. Can previews be shared with external reviewers, including anonymous users, and how does that work with permissions?
A. Yes. WSE preview links handle this. Create a dedicated role with preview access, assign it to the reviewer, and share the link. The reviewer does not need a full Drupal account, so this works for anonymous users too. The workflow is straightforward: prepare the role, generate the preview link, share it.
Infrastructure and Performance: Will This Break What Already Works?
Q. If I have a CDN or Varnish cache, will Workspaces need anything extra?
A. No. There are no changes to your anonymous content delivery. The active workspace is live 100 percent of the time for anonymous users, so the workspace system is invisible to them. The same caching setup that works for your anonymous visitors keeps working. The only thing to confirm is that your configuration is appropriate for the content editors using the site, which is standard practice.
Q. How about performance?
A. This is the most important architectural property of Workspaces. When the active workspace is live, which it is 100 percent of the time for anonymous users, the workspace system is invisible, and your production site performs exactly as if Workspaces did not exist. That has been true since the architecture was first built in the Content Preview System (CPS) in 2014, and it is why Workspaces has run on some of the highest-traffic sites in the world for over a decade. Inside a workspace there is some overhead, but that is editorial traffic, a tiny fraction of your total load. Editors get a full-site preview, and visitors get full production speed.
Content Safety and Security
Q. If public files are uploaded inside a workspace, are they accessible to users who know the URL?
A. Yes. File entities in Drupal aren't revisionable, so the Workspaces module can't scope a file to a workspace the way it scopes nodes. The moment a file is uploaded to public://, it's written to the default live storage in sites/default/files and served directly by the web server, with no Drupal access check in the request path.
So even when the node or media entity that references the file lives only in an unpublished workspace, the file itself is already on disk and reachable at its direct URL by anyone who has or guesses it. Publishing state doesn't gate it. Public means public, and only the obscurity of the filename keeps it from being found.
If the file needs to stay private until publish, use a private:// file field, which routes downloads through Drupal so access checks apply, or a module like File Unpublish, which keeps public files of unpublished media entities inaccessible until the entity is published.
Configuration Management: The Gray Area Teams Care About
Q. How does WSE Config interact with Drupal's configuration export/import system?
A. Once a workspace is published, whatever is live is what you would export, the same as always. For sites that manage configuration directly on the site rather than exporting it to code, this is largely a non-issue. For sites with strict configuration management workflows, WSE Config is still maturing (the session described it as almost production ready), so test it in a non-production environment before you rely on it in production.
Collaboration and Conflict Management
Q. What happens when two people edit the same content in different workspaces?
A. They cannot, and that is deliberate. Once an entity is modified in a workspace, it is tracked there, and another editor cannot modify it in a different workspace. This is a feature, not a limitation. Automatic merging of structured content fields, entity references, and media relationships leads to data corruption, and every system that has attempted it has run into fundamental issues.
Workspaces takes the same approach as a well-run development team: coordinate through communication. Shared workspaces let teams collaborate, content ownership keeps responsibilities clear, and WSE lets you move content between workspaces when needed. If content is locked, discarding the change frees it again. The absence of automatic merging is a safety guarantee: your workspace will never contain content you did not put there.
Q. How does Workspaces handle deleted content?
A. Deleting content in a workspace is a special case, because the content needs to disappear from your workspace preview while staying visible on the live site until you publish. Workspaces solves this with the Trash module. Within the workspace, deleted content drops out of listings, views, and search results, but on the live site it remains visible until publish. Content deleted in a workspace stays recoverable until you publish, and this integration also removes an older constraint so that any entity type can participate in workspaces, not just those with a publication status.
Content Moderation and Workflows
Q. How does Workspaces work with content moderation and Drupal's workflows?
A. Workspaces integrates with Drupal's core Workflows module. You can move an entire workspace through workflow states such as draft, review, approved, and published, so the whole collection of changes moves through the approval process as a unit. Your legal team reviews the complete workspace, your content manager approves the entire set, and when it reaches the publish state the whole workspace deploys atomically. The Content Moderation and Workspaces integration is nearly complete, with one remaining issue to resolve in core, and the simplified content workflow initiative will make the two work together for more complex scenarios where different entities need different approval paths.
Ecosystem and Future Considerations
Q. Does it work with Canvas?
A. Yes. Workspaces is compatible with Canvas. The implementation differs, because Workspaces aligns with the Layout Builder approach rather than Canvas's own, but the two work together.
Q. Why is Workspaces a good fit for AI content generation?
A. Workspaces gives AI content generation the boundary it needs. AI content tools are scaling quickly, and Drupal's AI module integrates dozens of providers with automators that can bulk-populate fields, generate summaries, and translate content. But AI is non-deterministic: it can hallucinate and produce errors. Workspaces provides the natural safety architecture. Think of a workspace like a pure function: everything inside is safe and reversible with no side effects. An AI agent can generate content, edit fields, and populate entire sections inside a workspace, and nothing touches live until a human reviews the changes and publishes. The workspace diff makes that review straightforward. The result is governed automation, where AI helps and humans stay in control.
Q. What is on the roadmap?
A. The architecture is sound, and the remaining work is about closing the last gaps and proving the system in the wild. Content Moderation and Workspaces are nearly integrated, with one issue left in core. WSE Config, which stages configuration changes alongside content, is almost production ready. WSE Theme lets you preview an entirely different theme staged in a workspace. What the system needs most now is real-world testing: try it with your contrib modules, test it with your custom entity types, and report bugs when you find them. Every production deployment proves the architecture.
Workspaces is stable, it is in core, and it is the right architecture for content governance at scale, including AI content generation.
13 Aug 2026 12:00am GMT
12 Aug 2026
Drupal.org aggregator
Omega8.cc: Dev Sites and Sandboxes
Every Drupal or Backdrop site sooner or later needs a safe copy to experiment on - plenty of us still build one by hand and live with the quiet fear that the copy touches production, and plenty more click a dev-environment button inside somebody else's walled garden. On a BOA server the whole workflow is delegated: one Ægir task clones the site from a fresh backup, and the copy arrives with the handbrake pulled - cron off, HTTPS off, files in its own store - then dev-prefixed names mark the copies as dev sites with their own larger limits, a dev alias flips PHP errors and caching into dev mode on that hostname alone, allow-lists and HTTP auth lock the copy down, extra clones Migrate onto updated codebases for staging, and a rename promotes the winner when it earns the crown - while to the rest of the stack the sandbox is a site like any other, nightly backups and edge protections included. Capabilities, not an enforced workflow - the safe route is the easy one, never the only one.
12 Aug 2026 7:20pm GMT
The Drop Times: Drupal GovCon 2026 Speakers Examine Bots, AI Trade-Offs, Accessibility, Search, and Migration
Eight additional Drupal GovCon respondents focus on the controls, human decisions, and content structures that keep digital systems usable when automation and changing discovery meet production reality.
12 Aug 2026 4:53pm GMT
Stuart Clark (Deciphered): JSON:API Views 8.x-1.2
JSON:API on its own gets you decoupled entities: fetch a node, fetch a set of IDs, done. It doesn't get you the filtering, sorting and pagination that most real content listings actually need - a list of articles by tag, a paginated product catalogue, an events calendar with a date filter. You either reimplement that logic on the frontend, or Drupal ships a hand-written custom resource for every list on the site. That gap is the same regardless of what's rendering on the other end, React and Next.js, Vue and Nuxt, or anything else that can call an API.
JSON:API Views closes it: whatever a View can already do, a decoupled frontend can ask for over JSON:API, using the access checks and query logic the view already has, no separate endpoint to write or maintain. It's also, not coincidentally, why I still maintain the module at all: it's the backend half of DruxtViews, the piece that makes Views work in Druxt, my own Nuxt-based decoupled Drupal framework.
12 Aug 2026 6:50am GMT
Webpro Company blog: Managing Drupal content with ChatGPT and MCP
Drupal content can be managed by machines without giving up human control. The key is not to hand ChatGPT the full admin interface, but to expose narrow MCP tools: find an article, open a draft, propose a change, validate it, show the diff and let a human approve publishing. Managing Drupal content with ChatGPT and MCP ChatGPT, Claude, Codex and other AI tools do not have to stop at writing text in a chat window. With the right interface, they can request context from a website, find existing content, suggest edits and prepare changes. This is especially interesting with Drupal because Drupal content is usually already structured: content types, fields, translations, roles, permissions, workflows, revisions and logs. That does not mean AI should freely click around the admin interface.…
12 Aug 2026 6:00am GMT
Webpro Company blog: How to evaluate a Drupal developer's competence
When you hire a Drupal developer or change maintenance partner, do not ask only for a portfolio. Ask how they keep the system upgradable, testable and understandable for the next developer. In 2026, it is no longer enough to evaluate a Drupal developer simply by knowing that they have "worked with Drupal". Drupal is a broad enough platform that the same job title can cover very different types of work: configuring content types and Views; developing custom modules; migrations; performance optimisation; security updates; accessibility; integrations with external systems. A good developer does not need to be equally strong in every area. They should, however, be able to assess realistically where their strengths lie, where they need support, and how to keep risks under control throughout…
12 Aug 2026 6:00am GMT
11 Aug 2026
Drupal.org aggregator
Drupal Association blog: Responding to Drupal Enquiries with a Community-First Mindset
This is a guest post from the team at Zoocha, a Gold Drupal Certified Partner with offices in the United Kingdom, Spain, Brazil, and the United States.
As Drupal agencies, we're fortunate to benefit from a vibrant ecosystem that generates awareness, interest, and opportunities for all of us. At Zoocha we receive inbound enquiries from a variety of sources. Whether they arrive via Drupal AI, Drupal CMS, a community recommendation, a Drupal event, or direct through our site, every enquiry often represents something important: a person taking their first step towards our community.
Not every lead is a project.
Not every lead has a budget.
Not every lead is ready to buy.
But they always deserve a meaningful response.
The First Impression of Drupal
When someone reaches out to a Drupal agency, they're rarely just evaluating that agency, they're more often than not seeking to engage with Drupal itself. For many prospective clients, they may not know the difference between Drupal, the Drupal Association, Drupal CMS, an implementation partner, a hosting provider, or the wider open source community. They simply know they've heard about Drupal and are looking for guidance.
The response they receive helps shape their perception of the entire ecosystem. If their first interaction feels dismissive, transactional, or overly focused on qualification, they may walk away believing that's what the Drupal community is like. If their first interaction is friendly and genuine, they leave with a very different impression.
Resist the Urge to Qualify Too Early
Most agencies have some form of qualification process. It's sensible, and so do we. Time is valuable, and we know not every conversation will become a project.
However, there is a difference between understanding someone's needs and interrogating them. We've all seen responses that immediately ask:
- What's your budget?
- What's your timeline?
- Have you secured funding?
- How many pages does the site need?
- Can you complete this requirements questionnaire?
While those questions have their place, they are rarely the most important thing during an initial conversation. Many prospects simply don't know the answers yet.
Some are conducting research. Some are exploring options. Some are trying to understand whether Drupal is even the right fit. At this stage, what they often need most is guidance.
Be Helpful Without Expectation
One of the most effective approaches we've found at Zoocha is to assume that the first conversation may never lead to a sale. That does sound counterintuitive for a commercial organisation, but it changes the nature of the interaction. Instead of trying to move the conversation towards a proposal as quickly as possible, we focus on being useful. That might mean:
- Answering questions about Drupal CMS
- Explaining how Drupal compares to other platforms
- Pointing someone towards community resources
- Offering advice on procurement approaches
- Helping clarify requirements
- Suggesting next steps, even if they don't directly involve us
Sometimes that conversation ends there, and that's ok. The contact doesn't leave empty handed. They leave with a positive impression of who we are in the Drupal community.
The Long-Term Value of Community-First Thinking
Interestingly, some of our most successful client relationships started with conversations that had no immediate commercial outcome. We've had early exchanges that were little more than an idea, with individuals facing a specific challenge and just looking to find out if they're even in the right place with Drupal. After a person-first conversation, they disappeared. But a few months, or even a year, later, they came back, and what began as a casual enquiry became a long-term client partnership.
This didn't happen because we had the best sales team or process. It happened because we prioritised human connection over a fast sale.
Open Source Values Apply to Business Development Too
Drupal has always been built around principles of collaboration, openness, and knowledge sharing, these values really shouldn't stop at code contributions. They can also shape how we engage with prospective users of the platform. When we answer questions generously, share expertise freely, and help organisations make informed decisions, we're strengthening confidence in Drupal itself.
Even if a particular opportunity never becomes a client engagement, the person on the other end of that conversation is left with a positive impression of the community. That's good for all of us!
Conclusion
The next time a speculative Drupal enquiry lands in your inbox, try viewing it differently. Consider simply asking, "How can we actually help this person?" The answer might only require a short email, a useful link, or a brief conversation, and yes, the immediate commercial return is likely to be zero. But the long-term return, for your agency and for the Drupal ecosystem, can be significant.
Every first interaction is an opportunity to demonstrate what makes the Drupal community different. Let's make sure it's a positive one.
11 Aug 2026 8:00pm GMT
Aten Design Group: Choosing a Multisite Approach in Drupal
Choosing a Multisite Approach in Drupal Joel Steidl Drupal
Organizations usually begin considering a multisite approach (the ability to manage multiple distinct websites from one single Drupal instance) when they are scaling their digital presence. This scaling is not only about traffic, but also about organizational structure.
Common drivers include:
- the need to support many related brands, locations, or programs that require their own websites
- pressure to reduce long-term maintenance costs and duplicated effort
- desire to balance central governance with local autonomy, while maintaining shared design systems or functionality across multiple properties.
A multisite architecture is not always the right answer. It often introduces additional complexity and is rarely justified when sites have fundamentally different goals or audiences, when editorial teams require complete independence, or when there is insufficient technical capacity to support shared infrastructure.
When a multisite approach does make sense, there are several established patterns in Drupal. Each pattern solves a different organizational problem and comes with meaningful tradeoffs.
Single Codebase, Multiple Sites
This category includes approaches where many independent Drupal sites share a common codebase while maintaining separate databases, configuration, and content.
Two common implementations of this pattern are custom upstreams (commonly used on Pantheon) and Acquia Site Factory. These approaches are often discussed together, but they differ in important and practical ways.
Custom Upstreams
What it is
Custom upstreams allow multiple Drupal sites to inherit from a shared upstream Git repository. Each site is a fully independent Drupal installation. The upstream defines only the shared code, and perhaps a starting point for the site configuration.
Sites choose when to pull updates and can diverge when necessary.
Best fit when
- You have many similar sites such as offices, chapters, or locations.
- Central engineering teams manage releases.
- Site autonomy and failure isolation are important.
- Governance can be handled through process rather than tooling.
Pros
- Clear separation between sites, including content, configuration, and databases.
- Centralized feature and security updates.
- Predictable deployments and rollbacks.
- Site-specific issues are easier to debug and reason about.
- Strong failure isolation between sites.
Cons
- Cross-site content sharing is difficult.
- Mass content updates require custom tooling or workflows.
- Site-level customization can lead to long-term divergence.
- Consistency depends on discipline rather than enforcement.
Summary
Custom upstreams optimize for operational clarity and independence. They scale well when sites are intentionally similar but not tightly coupled.
Acquia Site Factory
What it is
Acquia Site Factory is a managed multisite platform layered on top of Drupal and Acquia's hosting infrastructure. In addition to sharing code, Acquia Site Factory provides a central control plane for provisioning, governance, and operations across a large portfolio of sites.
The platform is designed as a true site factory, with templated site creation and centralized management.
Best fit when
- You manage very large site portfolios, often numbering in the hundreds.
- Governance, compliance, and standardization are primary concerns.
- Non-technical users need to create new sites.
- Central control is valued over flexibility.
Pros
- Centralized site creation and lifecycle management.
- Built-in governance, roles, and permission models.
- Templated site provisioning at scale.
- Integrated security, monitoring, and platform support.
- Reduced operational burden for large programs.
Cons
- Higher platform dependency and lock-in.
- More opinionated workflows and constraints.
- Less transparency into the underlying architecture.
- Cost and complexity may be excessive for smaller portfolios.
- Failure domains may be broader depending on platform configuration.
Summary
Acquia Site Factory optimizes for governance and scale. It trades architectural flexibility for centralized control and operational efficiency.
A critical distinction
While both approaches support a single codebase with multiple sites, they emphasize different priorities.
- Pantheon Custom Upstreams emphasize site autonomy.
- Acquia Site Factory emphasizes centralized governance.
This distinction affects deployment workflows, debugging, onboarding new sites, and the long-term evolution of the platform.
Traditional Drupal Multisite
What it is
Traditional Drupal multisite allows multiple websites to run from a single Drupal codebase using separate directories under /sites. Each site typically has its own database and configuration. All sites share the same runtime, deployment process, and underlying infrastructure.
This approach is built into Drupal core and remains fully supported.
Best fit when
- You manage a small number of closely related sites.
- Infrastructure simplicity is a priority.
- Centralized deployments are acceptable.
- Failure isolation is not critical.
Pros
- Native to Drupal with no additional platform requirements.
- Shared codebase with minimal tooling.
- Lower hosting and infrastructure costs.
- Familiar pattern for long-time Drupal teams.
Cons
- All sites share the same runtime and infrastructure.
- A deployment issue, performance problem, or outage can affect every site.
- Limited isolation between sites.
- CI/CD and rollback workflows are more complex.
- Risk increases significantly as the number of sites grows.
Summary
Traditional multisite optimizes for simplicity and cost reduction at small scale. Shared runtime risk becomes a significant drawback as complexity increases.
Drupal Domain module
What it is
The Domain module allows a single Drupal site and database to serve multiple domains or subdomains. Content is explicitly assigned to one or more domains at publish time.
Out of the box, content is not automatically shared across domains. Editors must intentionally choose which domain or domains the content belongs to.
Best fit when
- Domains represent closely related organizations, programs, or campaigns.
- Editorial teams overlap significantly.
- Content reuse is intentional and controlled.
- Centralized user management is important.
Pros
- A single codebase, database, and user system.
- Explicit control over where content appears.
- Content can be assigned to multiple domains when needed.
- Shared media libraries and assets.
- Centralized editorial workflows and permissions.
Cons
- Content sharing is manual and intentional rather than implicit.
- Editorial complexity increases as the number of domains grows.
- Menus, blocks, and layouts often require domain-specific configuration.
- Configuration management becomes significantly more complex.
- All domains share the same runtime and infrastructure.
- A failure or deployment issue affects every domain.
Summary
The Domain module shifts complexity away from infrastructure and into editorial experience and configuration management. Clear domain boundaries and editor training are essential.
Decoupled or Composable Multisite
What it is
In a decoupled approach, multiple sites share front-end applications, design systems, or component libraries. Each site maintains its own Drupal backend or content management system.
This pattern is typically part of a broader composable architecture strategy.
Best fit when
- Front-end engineering maturity is high.
- User experiences vary significantly.
- Design systems are a long-term investment.
- Teams already operate across multiple platforms.
Pros
- Maximum flexibility in frontend experiences.
- Clear separation of concerns.
- Independent evolution of design systems.
- Reduced coupling at the Drupal layer.
Cons
- Significantly higher technical complexity.
- Increased infrastructure and operational overhead.
- Slower initial development timelines.
- Strong DevOps and frontend discipline are required.
- Shared frontend infrastructure can introduce shared failure domains.
Summary
Decoupled multisite architectures prioritize strategic flexibility rather than cost savings.
Fully Separate Sites
In some cases, the best multisite decision is not to use a multisite approach at all and maintain separate websites.
Pros
- Maximum autonomy.
- The simplest editorial model.
- Complete isolation of failures.
Cons
- Duplicated effort and higher long-term cost.
- Difficulty enforcing standards.
- Feature parity becomes expensive over time.
Comparison Table
| Approach | Governance | Editorial Complexity | Technical Complexity | Content Sharing | Failure Isolation | Best For |
|---|---|---|---|---|---|---|
| Pantheon Custom Upstreams | Low to medium, process-driven | Low | Medium | Low | High | Many similar sites that require autonomy |
| Acquia Site Factory | High, platform-enforced | Medium | High | Low to medium | Medium | Very large, compliance-driven portfolios |
| Traditional Drupal multisite | Low | Medium | Medium | Low | Low | Small multisite portfolios |
| Domain module | Medium | High | High | Intentional and manual | Low | Closely related brands with shared teams |
| Decoupled multisite | Low to medium | Medium | Very high | Low | Low to medium | Highly differentiated experiences |
| Fully separate sites | Low | Low | Low | None | High | Independent organizations or brands |
Final Thoughts
There is no universally perfect Drupal multisite solution.
The real question is what are you optimizing your site for? Autonomy, consistency, speed, and shared content lead to different architectural decisions.
Most multisite challenges are organizational first and technical second. The right architecture reflects how teams work today and how they expect to scale in the future.
Get in touch with us to talk about the best multisite options for your organization.
11 Aug 2026 3:56pm GMT
BloomIdea: Rendering Mermaid diagrams in Drupal, and the highlight.js trap along the way
This started with an agent writing a comment into our Drupal intranet. It had traced an authentication flow, decided a sequence diagram was the clearest way to say it, and wrote one. What landed on the page was a grey box of monospaced text.
That is a small failure with a wider shape behind it. A growing share of what gets written into a Drupal site is no longer typed by a person into CKEditor. It arrives through an API, from a script, from an agent with an MCP connection to the site. And whatever writes it, the diagram comes out the same way:
<pre><code class="language-mermaid">sequenceDiagram
Alice->>Bob: hello</code></pre>
That is not a choice anyone made. It is what a fenced ```mermaid block becomes when Markdown is converted to HTML, which is the shape a language model writes in because it is the shape it was trained on. It is also, independently, exactly what CKEditor 5's Code Block plugin emits when a human picks a language from the dropdown. Human authors and machine authors converge on the same markup, which is a convenient thing to be able to rely on.
Mermaid is worth supporting for the ordinary reasons too. The diagram stays as text in the field, so it is searchable, it diffs, and the next person fixes one line instead of rebuilding a PNG that nobody has the source for. But the reason it became urgent for us is the one above: content we did not hand-write was arriving in a form the site silently failed to render.
Getting it working turned out to be short, with one genuinely non-obvious trap in the middle. This post is the trap, wrapped in the working solution.
What already exists
Mermaid Integration is the contrib module. It has been around since 2020, it is maintained by people whose names you will recognise, and its filter renders diagrams from a [mermaid]...[/mermaid] shortcode.
That syntax is the whole problem, and it is worth being precise about why. No model will ever emit [mermaid] unprompted, because nothing in its training data looks like that. Neither will any Markdown converter, nor CKEditor, nor a paste from a README. A human can be told to switch to source view and hand-type a shortcode. A pipeline cannot be told anything, and it does not fail loudly: the content saves fine, the page renders fine, and the diagram is simply a code block forever.
So a shortcode-only integration is invisible to every non-human author your site has. That is a different problem from being inconvenient, and it is the one that decided this for us.
We wrote our own filter rather than fight that, and we are contributing code block support back upstream. More on that at the end.
The filter
The pattern to copy is Highlight.js Input Filter. Its filter does a cheap regex first and only attaches its libraries when the text actually contains a code block. That conditional attachment is the whole game when your library is measured in megabytes.
public function process($text, $langcode): FilterProcessResult {
$result = new FilterProcessResult($text);
// No diagram in this text: attach nothing, change nothing.
if (!preg_match(self::DETECT_PATTERN, (string) $text)) {
return $result;
}
$count = 0;
$processed = preg_replace_callback(self::BLOCK_PATTERN, /* ... */, (string) $text);
if ($processed === NULL || $count === 0) {
return $result;
}
$result->setProcessedText($processed);
$result->addAttachments(['library' => ['your_module/mermaid']]);
return $result;
}
Nothing surprising so far. Then you turn it on next to your existing syntax highlighter and the page breaks in two ways at once.
The trap: highlight.js has two halves
Our site runs Highlight.js Input Filter on the same text format. The moment a language-mermaid block appeared, two things went wrong: a 404 in the console on every page with a diagram, and syntax highlighting painted underneath the rendered graph.
The 404 is easy to explain. That module scans the text server-side for language-* classes and passes the languages it found to the browser in drupalSettings, and the front end then imports a grammar per language from a CDN. There is no Mermaid grammar in highlight.js, and there never will be, because highlighting and diagramming are not the same operation. One paints tokens and leaves the text as text. The other deletes the block and draws something else in its place. So the import 404s:
GET https://unpkg.com/@highlightjs/cdn-assets@11.9.0/es/languages/mermaid.min.js 404
The obvious fix is filter weight. Give your filter a negative weight so it runs before the highlighter, take the block out of the way, done.
It is not enough, and this is the part worth remembering. The highlighter has a second half that filter weight cannot reach. Its JavaScript calls:
hljs.highlightAll();
highlightAll() walks every pre code element in the document and auto-detects a language for each one. It does not consult drupalSettings. It does not know or care what your PHP decided. Ordering filters fixes the server-side half and leaves the client-side half completely untouched, which is why the double-render survives a fix that looks like it should have worked.
So the filter has to change the markup, not just run first. Two edits, one per half:
// Before: what CKEditor stored.
<pre><code class="language-mermaid">…
// After: what our filter emits.
<pre data-bloom-mermaid="1"><code class="nohighlight">…
The attribute on the <pre> defeats the server-side half, because that module's regex requires a bare <pre> immediately followed by <code:
'/<pre>\s*<code\s+class="\s*(?:[\w-]+\s+)?\b[\w-]*lang(?:uage)?-([\w-]+)\b/i'
Add any attribute and it stops matching, so mermaid never reaches drupalSettings and the 404 never happens.
The nohighlight class defeats the client-side half. It is the class highlightElement checks before giving up on an element:
const shouldNotHighlight = (languageName) => /^(no-?highlight)$/i.test(languageName);
Both, or you have only half a fix. We have this written down in the repo with a note not to remove it, because the rewrite looks redundant if you only know about the filter ordering.
There is a neater variant available if you control the output shape. Contrib's module emits <pre class="mermaid"> with no <code> element inside at all, and highlightAll() selects pre code, so the collision simply cannot occur. We kept the <code> because we wanted a readable code block as the failure mode. Pick whichever tradeoff you prefer, but pick deliberately.
Vendor the library, and know what you are vendoring
Contrib pulls Mermaid from cdn.jsdelivr.net with no version pin. We wanted the file in the repo: no third-party dependency in the critical path of an internal page, and no surprise when a major version lands.
The tidy Drupal answer is composer require npm-asset/mermaid, which installs into web/libraries. We measured before committing to it, and the numbers ended the discussion. Mermaid 11.16.1 unpacks to 83 MB across 1171 files, about 26 MB of which are source maps that never reach a browser. web/libraries is tracked in git in our project, so that is 83 MB of repository for one diagram renderer.
What you actually need is one file. dist/mermaid.min.js is the self-contained UMD build, 3.6 MB raw and 975 KB gzipped, and it sets globalThis.mermaid. We vendored that single file with a README next to it recording the version, the licence, the exact source URL and the upgrade command.
3.6 MB is still a lot, which is exactly why the conditional attachment matters. A page with no diagram downloads none of it. We also set preprocess: false on the library so a file that size stays out of the aggregated JavaScript bundle:
mermaid:
version: 11.16.1
js:
js/vendor/mermaid.min.js: { minified: true, preprocess: false }
js/mermaid-init.js: {}
dependencies:
- core/drupal
- core/once
Two details in the JavaScript
Read textContent, never innerHTML. The stored markup escapes the arrows, so a sequence diagram is sitting in the database as A-->>B. textContent gives you the decoded text that Mermaid's parser expects; innerHTML hands the parser the entities and it fails on every diagram with an arrow in it, which is to say all of them.
A broken diagram must never break the page. Someone will eventually get the syntax wrong in a comment, and a syntax error in one diagram cannot be allowed to take down a task page. So the render is wrapped, the failure is silent, and the original code block stays visible and readable:
mermaid.render(id, source)
.then((result) => { /* replace the <pre> with the SVG */ })
.catch((error) => {
// Degrade to the plain code block.
pre.classList.add('bloom-mermaid-error');
console.warn('Mermaid: diagram not rendered.', error);
});
Set securityLevel: 'strict' while you are there, and suppressErrorRendering: true so Mermaid does not inject its own error graphic into your page when a parse fails.
One more that cost us a test to find: Mermaid leaves a throwaway measurement element in document.body when parsing throws. It cleans up after a successful render but not always after a failed one. Remove #d<your-id> in a finally.
Adding it to the editor
Last step, and easy to forget: put Mermaid in CKEditor's Code Block language list, so authors can pick it from the dropdown instead of needing source view.
plugins:
ckeditor5_codeBlock:
languages:
# …
-
label: Mermaid
language: mermaid
Export that config. If it only exists in the active store, the next config:import takes it away again.
Contributing back
None of the above is Mermaid-specific except the library name. Any renderer that replaces a code block rather than colouring it hits the same two-halves problem: PlantUML, Vega-Lite, ABC notation, chemical structures. If you build one of those, the ordering fix will look like it worked and it will not have.
Two merge requests are open against Mermaid Integration:
- #3616088 adds code block support alongside the shortcode, carries the highlight.js de-confliction, and makes the library attachment conditional instead of unconditional.
- #3592975 adds the config schema the filter currently lacks. Without it, installing the module blocks saving any text format on Drupal 11.3, whether or not the Mermaid filter is enabled anywhere.
Reviews welcome.
As for the comment that started this: the agent reran it after the filter went live, and the diagram drew. Which is the useful test, in the end. If the machines writing into your site cannot render a diagram, neither the machines nor the people reading after them get one.
11 Aug 2026 1:18pm GMT
Specbee: How to build accessible Drupal Themes with Twig and BEM
Accessibility in a Drupal theme starts in your .html.twig files. Here's a practical guide to learning how to structure templates with semantic HTML5 and BEM class naming.
11 Aug 2026 11:09am GMT
The Drop Times: Drupal GovCon 2026 Speakers Preview AI Governance, Migrations, Performance, and Delivery
Several Drupal GovCon speakers are looking past demos and idealised workflows to the harder questions of what government teams can govern, maintain, afford, migrate, and trust in real projects.
11 Aug 2026 5:09am GMT
Cheppers: ExperienceKit: AI Landing Page Generation for Drupal - How It Actually Works
Describe the landing page you need in plain language. A few minutes later, it exists in your Drupal site: production-ready, on brand, and waiting for your review. That is the promise of an AI landing page generator for Drupal, and it is no longer a demo trick. It works, it is reliable enough for enterprise sites, and it changes how marketing and development teams divide their work.
11 Aug 2026 12:00am GMT
10 Aug 2026
Drupal.org aggregator
ImageX: Meet Drupal Canvas: A Faster, Smarter Way to Build Content
The latest chapter of content management within Drupal officially started with the release of Drupal Canvas. And we have to admit, the pages in this chapter look fantastic!
10 Aug 2026 5:59pm GMT