How does a Drupal page tell machines that its content was made with AI?

This article looks at the part of the AI label a machine reads: the property, the value, where it sits in the page and what writes it. The module is AI Disclosure, which I created on drupal.org from the Drupal AI Initiative plan. When the label is mandatory is covered in the article on Article 50(4) of the AI Act in Drupal. With two elements in the <head>: a JSON-LD block carrying the schema.org property digitalSourceType, and an ai-disclosure meta tag. AI Disclosure writes both on the canonical page of every piece of content with a resolved disclosure, starting from the grade the editors gave it. This is the block the site outputs today, in production, on the Italian version of the AI Disclosure project page: And this is the meta tag on the same page: Nobody writes either of them by hand. The editor picks a grade in the content's field, and the module derives the rest.
A great leap backwards: fixed configuration
Drupal's configuration system has at its heart a key concept: the site owns the configuration. What that means is that after a module has provided install configuration, it no longer has any control over it. You, the site admin, can change that config or even delete it. The module is no longer involved.
This kept the configuration system simple (up to a point); after all, the development of this system was one of the harder parts of the lengthy and difficult Drupal 8 cycle ("The ConfigImporter class was written with a get this done and working attitude" wrote @alexpott on a core issue, and I think the same could be said of the configuration system as a whole).
Since then, the config transformation API was added, and various modules have been created that take advantage of this, such as Configuration Split and Config Merge. These still work in the paradigm of the site owning the configuration. But what if we could turn the clock back, just partially, to when modules could own config too?
The (different) old daysIf you were around in the days of Drupal 7, you may remember the various default hooks. Modules such as Views and Flag exposed a hook which allowed modules to define configuration items. (These were not configuration in the modern sense, because there wasn't that concept at the time, but referring to them as such makes things simpler.)
These were thus a code-defined instance of a type of thing that could also be defined in the UI by site admins. A module could supply a default view, and rely on it always existing. A new release of a module could come with enhancements to a that view, and they would exist on the site as soon as the module code was updated to the new version.
A great leap backwards: fixed configuration
Drupal's configuration system has at its heart a key concept: the site owns the configuration. What that means is that after a module has provided install configuration, it no longer has any control over it. You, the site admin, can change that config or even delete it. The module is no longer involved.
This kept the configuration system simple (up to a point); after all, the development of this system was one of the harder parts of the lengthy and difficult Drupal 8 cycle ("The ConfigImporter class was written with a get this done and working attitude" wrote @alexpott on a core issue, and I think the same could be said of the configuration system as a whole).
Since then, the config transformation API was added, and various modules have been created that take advantage of this, such as Configuration Split and Config Merge. These still work in the paradigm of the site owning the configuration. But what if we could turn the clock back, just partially, to when modules could own config too?
The (different) old daysIf you were around in the days of Drupal 7, you may remember the various default hooks. Modules such as Views and Flag exposed a hook which allowed modules to define configuration items. (These were not configuration in the modern sense, because there wasn't that concept at the time, but referring to them as such makes things simpler.)
These were thus a code-defined instance of a type of thing that could also be defined in the UI by site admins. A module could supply a default view, and rely on it always existing. A new release of a module could come with enhancements to a that view, and they would exist on the site as soon as the module code was updated to the new version.
Measuring ChatGPT ads on Drupal, from the browser and from the server
Since September, advertisers in Europe can buy ads inside ChatGPT, and the Ads Manager asks for two things before it can tell you whether they work: a measurement pixel in the browser and, ideally, conversions sent from your server. On a Drupal site that usually means pasting a snippet into the theme, writing the order_created call by hand in a template, and trying to hide the whole thing behind the cookie banner. Then the order paid by bank transfer or payment reference hours later, confirmed by a webhook, never shows up, because no browser was there to see it.
Even when a browser is there, the pixel loses part of the picture. Ad blockers stop it outright, Safari caps cookies written by scripts at seven days, and iOS removes tracking parameters from links shared in Messages and Mail and from links opened in private browsing. OpenAI's own documentation calls the Conversions API "a more reliable tracking source than the pixel alone".
We have released a module for this on drupal.org: ChatGPT Ads, free software under the GPL, for Drupal 10.3 and 11, covered by Drupal's security advisory policy. It plugs into Drupal Commerce, Webform and the Klaro consent manager through sub-modules, and sends events through both OpenAI's Measurement Pixel and the Conversions API. It is a community module, not affiliated with OpenAI.
Drupal's Got Talent at DrupalCon Orlando 2027!
The inaugural DrupalCon Talent Show is happening at DrupalCon Orlando on the evening of Tuesday, March 23, 2027 as part of the community party!
We’re planning about two hours of entertainment and looking for roughly 10 acts to take the stage (5–7 minutes for the act, plus up to 3 minutes for stage setup).
This is DrupalCon. The goal is to learn, network, and have fun. Expect jokes, friendly razzing, questionable decisions, and plenty of laughs. You don’t need to be a professional. You just need to be willing to get up there and attempt to entertain your fellow Drupalers (within our Code of Conduct https://events.drupal.org/code-conduct, of course!)
What are we looking for?
Pretty much anything entertaining:
- Musicians
- Bands
- Stand-up comedy (keep it PG-13 please!)
- Magic
- Singing
- Dancing
- Juggling
- Puppet shows
- Ridiculous feats of skill
- Weird talents you didn’t think anyone wanted to see (we do)
Got something that doesn’t fit on the list? Even better. Solo acts, groups, first-timers, seasoned performers, and wonderfully questionable ideas are all welcome.
Think you’ve got something? Sign up here and show us what you’ve got!
FAQs
When is the deadline?
The absolute last deadline to sign up is Friday, February 19th. However, submissions are reviewed on a rolling basis as they come in. Once all ~10 spots are filled, sign-ups will close early. We strongly encourage you to submit as soon as possible.
Is there a prize?
Likely, but this hasn’t yet been determined. Suffice it to say that the primary prize will be bragging rights!.
Drupal to WordPress Migration: When Downgrading Is Right
AI / Vibe Coding in Drupal: A Practical Example
A request from a product owner: their Drupal website has a content type called 'Event'. The editorial team wants to display a block on the homepage showing the next three events.
The initial request and AI prompt“Create a Drupal block that displays the next three events, sorted by start date. Give each event a title, date, and link. The events must also be published. Also take recurring events into account. Please do this 'programmatically', not in Views, because I expect more complexity and external integrations later in this development process.”
Instead of first working out all the code themselves, a Drupal developer can use AI as a programming partner. This is vibe coding: you mainly describe what you want to achieve, have AI generate an initial implementation, and continue developing based on testing and feedback.
Drupal 11: Migrating From Jadu Into LocalGov Drupal: Part 4
This is the fourth article in a series looking at migrating from Jadu into LocalGov Drupal (LGD) for the Central Bedfordshire site. In the first article we looked at the Jadu API itself 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.
In the third article we looked at a more complex example of migration, taking documents and pages from Jadu and creating a guide pages from that data.
Now it is time to move onto what became the most complex part of the Central Bedfordshire migration, which was moving directories data from Jadu to LGD. Directories were used on the Jadu site to store all sorts of information, which included schools, the location of car parks, contact information of homecare providers, and even an a-to-z glossary of recycling. This data served different purposes on the site, but it was all hand created and important to bring across during the migration work.
In this article we will look at the Jadu data we needed to fetch to find directory information, and how that data was injected into the LGD structure available.
First, let's look at how we get directory information out of Jadu.
Jadu Directories APIDirectories in Jadu can be fetched using the directories index at the following endpoint.
philipnorton42 Sun, 09/27/2026 - 18:45PHP Structured Concurrency and Beyond (4): call for backers
The prototype works. Taking it to production quality is more than evenings. Whether it should is a question, not a pitch.
One thing before the rest. I am not pushing this. The series is a question to the world: is this work worth more of my time? We are not in the Federation yet, so more time means money, and money means backers. Any answer is fine with me, including no.
Why isn't this Drupal page cached?

You read the reason Drupal itself writes on the response, provided you kept it. The page cache and the dynamic page cache put their verdict in the X-Drupal-Cache and X-Drupal-Dynamic-Cache headers: HIT, MISS, or UNCACHEABLE followed by the rule that decided it in brackets. Those headers reach the browser and stop there: the server keeps no copy of them. Native Observability is a Drupal module that records from the inside what happens during each request. Its Cache Observer submodule, native_observability_cache_observer, stores in the database the outcome of each cache layer, the cacheability metadata of the response and the cache tag invalidations, tied to the route and to the trace of the same request. Slow queries for the same request are covered in the article on the queries that slow down a route, calls to external services in the one on the external service that slows down a route.
Which external service is slowing down this Drupal route?

You time every outgoing call while the page is still being built, and write the page name next to the timing. The external service cannot tell you, because all it sees is a request from an IP address, and Drupal on its own keeps nothing of what it called. Native Observability is a Drupal module that records from the inside what happens during each request. Its Spans submodule times outgoing HTTP calls, and the Dashboard groups them by page: for each route it tells you which services were called, how many times, with what average duration and how many errors. The same problem for database queries is covered in the article on the queries that slow down a route. The numbers on this page come from a measurement environment I built, with a fake slow service whose delay I set myself. How to rebuild it is at the bottom, in the section on repeating the measurement.
How do I apply Article 50(4) of the AI Act to the content of a Drupal site?

This article looks at how AI Disclosure turns Article 50(4) into data and into a label on the page. What the module is and how it is built is covered on the project page. It is not legal advice: it sets out what Regulation (EU) 2024/1689 and the European Commission FAQ say, and what the module does with those rules. Whether a piece of content needs a label is up to whoever publishes it. The part a machine reads is covered in the article on how a Drupal page tells machines that its content was made with AI. Files have their own series on AI Disclosure 1.0.0-beta1: images. AI Disclosure keeps two things apart: how much AI went into the content, and whether the rule applies to that content at all. The first is the grade, one of nine.
Which queries are slowing down a Drupal route, and how you isolate them in production

You find it only if something wrote the page name next to the query while the request was running. Afterwards it cannot be reconstructed: the database keeps the slow queries, but to it they are statements that arrived over a connection, not pages of a site. Native Observability is a Drupal module that records from the inside what happens during every request. Its Database Observer submodule does one thing: when a query goes over a duration threshold, it stores one row holding two pieces of information side by side, the query and the page that ran it. This page covers three things: what you find inside that row, how far you can trust what you read, and where to start. How much the module slows the site down is a different question, and the measured answer is in the article about its cost.
How much does Native Observability slow Drupal down, and how do you measure it on your server

Native Observability is the Drupal module that records what happens inside every request, and instrumenting a site with it costs about 4.7 and about 7.0 milliseconds per request on the two machines where I measured it. Same code, same version, same measurement command, two numbers 48% apart. What the module does and how it is built belongs to the project page. This page is only about what it costs and how you measure that. The first figure is published in the module documentation, which states its conditions and where it came from. I took the second one myself, on a containerised DDEV environment, on 25 September 2026. The third row carries the most weight: switching off two submodules takes the cost from about 4.7 to about 1.8 milliseconds, cutting it by 62%. Both figures behind that cut come from the same paired run, not from comparing the first and third rows of this table.
PHP Structured Concurrency and Beyond (3): structured state, and why its absence breaks concurrency
Every framework service that holds state is a bug under fibers. The current fix is to switch concurrency off. There is a third option.
Druxt Auth 0.5.0; two ways to sign in without leaving your site
Every Druxt site I have built signs people in by sending them somewhere else to do it: out to Drupal's login page, on to a consent screen, and eventually back. With Druxt Auth 0.5.0 the username and password can now be handled entirely in the frontend instead, either through the authorization code grant or through the password grant.
If you have not used it, Druxt Auth wires Nuxt's auth module to Simple OAuth on the Drupal side. It targets Nuxt 2 today, because @nuxtjs/auth-next does.
The first is the authorization code grant, which now takes credentials directly. Druxt Auth signs the visitor in through Drupal's JSON login route first, so the authorize step finds a session waiting and returns a code without rendering anything:
amazee.io and amazee.ai Bring Shadow AI and Sovereign Infrastructure to DrupalCon Rotterdam
What’s New in ECA 3 And How to Build An Automated Drupal Workflow
Modern, intelligent Drupal websites rely on automation to save teams plenty of time. Tools like Drupal Cron handle scheduled tasks at set intervals, but not every automated workflow is tied to a schedule. Some need to respond immediately to events on your Drupal site, such as a user logging in, an article being published, or a custom form being submitted.
PHP Structured Concurrency and Beyond (2): ownership, and why its absence breaks persistent servers
A coroutine nobody owns is a leak. Under one process per request you never see it. Persistent servers take that away.