fidzu : Drupal

01 Sep 2026 1:02pm GMT

Drupal Canvas hides most Metatag fields behind one SEO title box. Check out how Canvas Page Metatag restores them and fixes a Robots checkbox bug.

01 Sep 2026 10:38am GMT

Every Drupal 7 to Drupal 11 migration we run follows the same 52 steps in the same order - audit, content model, module mapping, the 301 map, build, verification, and a cutover designed so rollback is one DNS change away. The full checklist, with the reasoning behind each step and a printable summary card.

01 Sep 2026 1:13am GMT

Reproducing a bug that only happens on the live Drupal site used to mean a hand-made dump, the uploads copied across one rsync at a time, and an hour of persuading the copy it is not production. On a BOA-hosted site it is one pull into the DDEV project you already have: a small add-on reads what the site reports about itself, sets the local project to the same PHP and Drupal version and the same docroot, then brings the database and the uploads down through the ordinary limited shell account you already use for SFTP, with the key you already have, and nothing new switched on server-side. It syncs one way only, on purpose, and the site's own Drush takes over once the copy is yours. Self-hosters get the other door: the whole stack on a spare VM at a private hostname, no public IP, no DNS, the same BOA as production. This post is the recipe, six commands from start to Pull succeeded, plus the small print neither door hides.

31 Aug 2026 9:30pm GMT

Drupal Meets Matrix part 1: Setting up Matrix API

John Locke Mon, 08/31/2026 - 14:30

Dev Corner

31 Aug 2026 9:30pm GMT

Imagen

Imagen

Carlos

Ospina

·

Technical Account Manager / Drupal Advisor

31 Aug 2026 5:54pm GMT

AI assistants increasingly sit between people and websites, retrieving and interpreting information on their behalf. That shifts the problem beyond whether software can connect to a site at all. The system also has to make clear what information means, what software may access, and which rules govern what happens next.

The Drupal AI Initiative made the first part of that problem explicit on 24 August 2026. Fields, taxonomy, relationships, metadata, and other forms of structured content can give software information that is easier to identify and interpret than meaning conveyed mainly through page design. Permissions and workflows add another layer by distinguishing what is public, restricted, current, or subject to editorial control.

A more concrete access boundary appeared this week in Acquia DAM's MCP Server. Compatible AI assistants can search assets, retrieve metadata, and obtain links through an authenticated connection that follows the user's existing DAM permissions. The initial implementation is read-only: an assistant can retrieve permitted information but cannot edit metadata or upload files. The interface therefore exposes capability without giving the software unrestricted authority over the system behind it.

GovCMS addresses a different machine-readable problem. On 27 August 2026, Rules as Code became a production capability on the platform, allowing policy, legislation, and business rules to be represented as reusable digital assets and embedded in digital services. Its first production implementation is an eligibility checker for agencies considering GovCMS, and the underlying eligibility rules are also published as open source. GovCMS describes the approach as a foundation for future AI-assisted services rather than as an AI-agent implementation today.

These developments are not three versions of the same architecture. They expose three related requirements for systems that software increasingly has to interpret or use: meaning must be explicit, access must be constrained, and important rules should not have to be guessed from prose. For Drupal teams, the agentic web may therefore depend as much on long-standing work around content modelling, permissions, auditability, and governance as it does on new AI capabilities.

Follow The DropTimes on LinkedIn, X, Bluesky, and Facebook, or join #thedroptimes on Drupal Slack.

This issue of Editor's Pick was written and curated by Allen Jason.

31 Aug 2026 4:40pm GMT

Two Drupal GovCon keynotes on building through disruption: the courage to lead change, and the care to keep people from being left behind.

31 Aug 2026 2:19pm GMT

31 Aug 2026 11:38am GMT

Specbee has joined the Drupal AI Initiative as a Certified Partner. See what Drupal AI initiative is about, how it's governed, and what it means for your enterprise site.

31 Aug 2026 5:10am GMT

Drupal 11: Migrating From Jadu Into LocalGov Drupal: Part 3

This is the second article in a series looking at migrating from Jadu into a LocalGov Drupal (LGD) site for the Central Bedfordshire site. In the first article we looked at the Jadu API and setting things up so that we could make calls to the API and parse the XML data using the migration systems available.

In the second article we looked at reproducing Jadu URLs to create redirects for migrated content, even though the Jadu API doesn't contain any URL information.

Now that we have a the Jadu connection created and redirects working we can start tackling other aspects of the migration, so let's look at migrating the main content of the site from Jadu. We can pull structured pages of content out of the Jadu API and apply them to the structure of a LGD site, maintaining the same hierarchical structure and order of pages.

Much of the content of a LGD site is built using just a handful of content types, and Central Bedfordshire was built in the same way. LGD comes with a number of content types that allow content editors to add content in different ways, which allows for some decent customisation in the structure and layout of a site. Not only that, but as we are using Drupal it is possible to customise this structure as much as we need to suit the needs of the site.

For Central Bedfordshire, we had the standard structure of the site built with Service Landing pages, which gave editors the ability to link out to other pages that contained all of the content. These inner pages were set up as Guide pages, and the migration of that content is what we will be focusing on in this article. Please note that I will need to gloss over a little bit of the detail in this article, but rest assured that the source code will be available soon.

philipnorton42 Sun, 08/30/2026 - 20:02

30 Aug 2026 7:02pm GMT

Four version control systems in three files, a hardcoded root password we decided not to airbrush, and a surprising amount of today's stack already in place. In the oldest corner of our static file mirrors sits a directory called alpha3, and in it three shell scripts dated 20 November 2009 - older than the public BOA repository itself, whose GitHub history only starts in January 2010. These are the scripts Barracuda & Octopus grew from: one installs the Ægir layer on a VPS, one upgrades it with cron stopped and a backup taken first, and one builds a whole menu of 2009-era Drupal platforms, from Open Atrium to ManagingNews. Now published byte for byte on our docs site, with a guided tour of what survived, from the /data/disk tree to the /dev/ delivery path.

29 Aug 2026 5:05pm GMT

It's time to prepare your Drupal modules for Admin's dark mode mherchel Fri, 08/28/2026 - 12:04

28 Aug 2026 4:04pm GMT

WebMCP is an emerging proposal for cooperation between a web page and a browser agent. It is not a new name for MCP and it is not a replacement. A practical rule is simple: MCP belongs near servers and data; WebMCP belongs near the live page and the workflow the user can see. At the end of August 2026, WebMCP is not something every production website should rush into every form. But it is worth understanding now, because the direction is right: an AI agent should not have to guess buttons and click through a website like a brittle automation script. A web application can declare which actions an agent may use and what structured inputs those actions expect. That distinction matters. A normal browser agent sees a page roughly as a user or automation tool sees it: headings, form fields,…

28 Aug 2026 6:00am GMT

Today we are talking about Security, Vulnerabilities, and how to avoid exposure with guest Dave Welch. We'll also cover Security Scanner as our module of the week.

For show notes visit: https://www.talkingDrupal.com/567

Topics

• What Are CVEs
• CVE Lifecycle and Disclosure
• AI Era Security Challenges
• What CVE Program Excludes
• Patch Fast Reality
• Global Security Signals
• CVE Timing Judgment
• KEV Flags Explained
• CVE Updates Link Rot
• Who Decides CVE
• Sneaky Patch Dangers
• ADP Program Fixes
• Small Team Triage
• Vulnerability Tsunami AI
• Autonomous Security Future
• Legal Pressure Budgets

Resources

• Psalm PHP Static Analysis Tool
• SARIF format
• PHP ecosystem
• Council of roots
• How AI Broke Open Source Security: End-of-Life Software Is the Most Exposed
• CVE podcast
• Vulncon
• PSIRT

Guests

David Welch - github: dwelch2344 dwelch2344

Hosts

Nic Laflin - nLighteneddevelopment.com nicxvan John Picozzi - epam.com johnpicozzi JD Flynn - dorficus

MOTW Correspondent

Martin Anderson-Clutz - mandclu.com mandclu

• Brief description:
  • Have you ever wanted a fast way to catch the security mistakes that slip into custom Drupal code - especially the code your AI assistant just wrote - before it ships? There's a module for that.
• Module name/project name:
  • Security Scanner
• Brief history
  • How old: created in July 2026 by Mayank Gupta (mayankguptadotcom) of Acquia
  • Versions available: 1.0.0, which works with Drupal 10.3 and 11
• Maintainership
  • Actively maintained - created and shipped its first stable this summer, with steady development right through late July
  • Security coverage
  • Test coverage - and it's strong: unit and kernel tests, including a regression corpus built from real Drupal core advisories
  • Documentation? In-depth README with a full check table and CI recipes, plus a CHANGELOG
  • Number of open issues: 1 issue, not a bug
• Usage stats:
  • 2 sites (it's brand new)
• Module features and usage
  • Provide a Drush command, has no UI - you point drush security:scan at a module or any path, it reads the code statically, and prints a prioritized, OWASP-mapped list of things to review
  • It's built for the age of AI-written code - the checks target the classes AI assistants keep reintroducing: routes with no access check, #markup and |raw XSS, missing CSRF tokens, unserialize() on untrusted data, hardcoded secrets
  • Then there's an optional deep pass: with the Psalm static analysis scanning engine installed, it'll trace untrusted input across functions and files to catch cross-function issues. And it's honest about state - the report always says whether that deep pass ran, was skipped, or failed, so a failure never gets mistaken for a clean scan
  • One nice detail under the hood: a tokenizer-backed "code map" that knows whether a match is real code, a comment, or a string - so it won't flag the word "unserialize" sitting in a doc comment. That kills the single biggest source of false positives
  • The checks are regression-tested against real Drupal advisories (Drupalgeddon, Drupalgeddon2, the 2019 unserialize bug, etc) so a pattern that caused an actual CVE can't quietly come back in your custom code
  • Output comes in three flavors: a readable table, JSON for CI and AI agents, and SARIF - which means findings show up as annotations right on your GitHub or GitLab merge-request diff instead of buried in a job log
  • For adopting it on an existing codebase there's a baseline file - you fingerprint the findings you've reviewed, with a required reason on each, and they stop failing the build but never go invisible; every run still counts them
  • It exits non-zero on error-level findings, so it drops straight into CI or a pre-commit hook
  • And it's extensible - checks are Drupal plugins with a #[SecurityCheck] attribute, so any module can add its own or alter the ones that ship
  • Big caveat, and the module says this itself: a finding means "review this," not "this is broken." Static analysis has false positives, and a clean scan doesn't prove the code is secure - access-control logic especially still needs human review
  • I first heard about this module over beverages at Drupalcamp Asheville, so I know that this module was largely vibe-coded, after having an AI agent ingest every single Drupal security team CVE. So I like to think of this module as security pattern recognition tool, but of course it does even more

27 Aug 2026 8:00pm GMT

Open Source is usually described as a licensing model, a development model, or a production model. All three descriptions are useful, but they leave something out. Every Open Source ecosystem is also a cost-allocation system.

Keeping software relevant and dependable requires people to write code, review contributions, prepare releases, investigate security reports, operate infrastructure, write documentation, answer questions, and support upgrades and migrations. Someone always bears those costs.

A proprietary vendor can tie access to payment: every license or subscription sold helps fund developers, security work, infrastructure, and releases.

Open Source breaks the link between access and payment. Anyone can redistribute the software at any price, including zero. Payment is therefore not a condition of using or redistributing it, and those rights do not themselves provide a durable mechanism for funding production and maintenance.

But separating payment from access does not make the costs disappear. Costs are distributed across maintainers, employers, foundations, sponsors, and users. A maintainer may volunteer their time. An employer may pay a developer to contribute. A foundation may operate infrastructure.

Because these costs are distributed rather than collected through a single transaction, they are harder to see and harder to fund.

Technical choices often shape where those costs fall. That allocation is not always deliberate; it can emerge slowly from decisions that were individually reasonable and become visible only years later.

Drupal's update service recently gave me a good example. Drupal sites periodically contact updates.drupal.org to ask whether new versions of Drupal or any installed add-ons are available. Drupal calls these add-ons "contributed projects", such as modules and themes maintained by members of the community.

The current design sends one request for Drupal itself and one for every contributed project installed on the site. A site with 100 contributed projects therefore makes 101 requests each time it checks for updates, by default, once a day.

There were good reasons for that design. Each project's release history could be stored as a static file and served repeatedly without rebuilding it for every request. The design was straightforward, and it worked.

But Drupal grew. Today, updates.drupal.org serves nearly a billion requests a month. The file containing Drupal Core's release history is roughly half a megabyte by itself. Based on the number of requests for that file, I estimate that Drupal Core update checks alone may account for roughly 50 to 75 TB of data transfer each month. Traffic for contributed projects comes on top of that.

No one chose to make updates.drupal.org transfer tens of terabytes of release data each month. That scale emerged gradually as Drupal grew, from a design that had been reasonable when the ecosystem was smaller.

Part of the challenge is that, in Open Source, the people who benefit, the people who decide, and the people who bear the costs are often different and may have no formal obligations to one another.

Site owners benefit from reliable update notifications, usually without paying the Drupal Association for them. Drupal Association staff operate the update service, while the Association bears its traffic and infrastructure costs. But the code that determines how sites make those requests lives in Drupal Core, where changes require the involvement of Core committers. The Core committers do not report to the Drupal Association, so the Association cannot change that behavior on its own.

In practice, Drupal Association staff and Core committers collaborate closely. That collaboration is important because decision-making authority and cost-bearing sit with different groups.

The people bearing material costs need a way to make those costs visible and influence the decision, even if they do not control it.

This example shows why every Open Source architecture is also a cost-allocation system. Good governance considers that allocation up front, monitors its effects over time, and revisits it when it becomes unsustainable.

Understanding an Open Source system therefore requires more than understanding its code or license. We also need to understand who benefits, who decides, and who bears the costs as the system grows. Once those relationships are visible, a community can decide whether the allocation is sustainable or whether the architecture should change.

27 Aug 2026 7:21pm GMT