What the Keynote Speakers Are Bringing to Drupal Developer Days 2025

Drupal Developer Days is back, and this year it’s happening in Leuven, Belgium, from April 15 to 18. Not just another tech meetup—this is where the people who make Drupal what it is show up, laptops open, ready to share what they’re working on, what’s changing, and what’s next.

It’s the 14th edition of the event, and it still holds onto what makes it matter: real conversations, sharp sessions, and that rare chance to code, question, and collaborate with the folks who live and breathe Drupal. Whether you’re neck-deep in backend code or tinkering with front-end performance, there’s something here that speaks to the work you’re actually doing.

This year’s focus stretches wide—AI, PHP’s evolving type system, WebAssembly, and the big-picture future of Drupal itself. To get a better sense of what’s coming, we spoke directly with the keynote speakers. We didn’t just ask for a preview—we asked why these talks matter now, and what they want the Drupal community to walk away with.

James Abrahams, Director at FreelyGive Ltd, will present “AI is the New UI – How We Are Building AI into Drupal CMS,” a session on building AI directly into the platform. Cristina Chumillas, Lead Engineer at Lullabot, is set to explore “Drupal CMS Now and Beyond,” focusing on Drupal’s current state and where it’s headed.

Gina Banyard, a PHP core developer and seasoned conference speaker, will break down the inner workings of the language in “PHP’s Type System Dissected.” Dr. Merlijn Sebrechts, senior researcher and lecturer at Ghent University and imec, and member of the Ubuntu Community Council, will explore new territory in “WebAssembly Beyond the Browser.” And Thijs Suijten, public speaker and technology expert, will take a broader view in “Innovating for Impact: A Developer’s Role in Shaping the Future,” a session about the bigger role developers play in shaping tech’s direction.

Let’s get into their full insights—what they’re exploring, why it matters, and what they want the community to take away.

James Abrahams

TDT[1]: In your keynote, you’ll explore how AI is making complex functionalities more accessible in Drupal. What are some of the biggest challenges in integrating AI-driven tools while ensuring flexibility for both developers and non-technical users?

James Abrahams: There are several challenges:

Firstly the key differentiator of Drupal compared to other systems is its wealth of modules, tools, integrations and actions that it has in its ecosystem that all operate together. So instead of building an agent architecture from scratch, we're having to work with the core Drupal subsystems made decades ago to make nicer blocks! However we're finding several very simple changes we think core will be happy with, that will mostly make core Drupal actions optionally more descriptive and provide a better and more controlled developer experience even without AI, we think we can suddenly unlock so much of the value of Drupal.

The other side to this is figuring out how we can make it easier for non-developers to find the tools and actions they are looking for and not get overwhelmed by everything! We can all remember 

"There is a module for that", there will be an AI version of "There is a tool for that". We need to make it much easier to find the tools their agents need"

Also we have to take this complicated world of AI Agents doing workflows that can achieve so much and create a user experience that a developer not verses in AI can make use of. So how much control do we give them versus do we hold their hand?

TDT[2]: Dries Buytaert recently raised concerns about AI-generated content at scale, such as incorrect product descriptions or overwritten accessibility data. How can Drupal ensure AI enhances content management without compromising editorial control and governance?

James Abrahams: We think Drupal is going to be amazing at being a place to handle AI-assisted content generation in a safe and secure manner.

We're going to need some level of "Spot checking" what AI does using "Smart Review Queues" in Drupal, but to do anything like this you need a content management system and workflow system with revisions that allow to to check someone else's work. Drupal already exists with its flexible open-source architecture that makes things easy for site-builders and end-users, we don't have to create the tools for people to check work from scratch, we can use what they are familiar with. We just need to make something for Drupal to provide the spot-checked content.

We already have tools for making revisions in content, but with the configuration management initiative saving content in config entities we should be able to version control our content, and provide audit trails. Relatively small changes to Drupal's AI architecture so the AI behaves like a user, we can use Drupal's existing tools to audit AI's behaviour, fix its mistakes and make small changes and tweaks to the output of AI for content and configuration.

Cristina Chumillas

TDT[1]: With Drupal CMS 1.0 released in January, your session will cover the development progress of the next version. What key processes have been followed so far, and how is the project tracking? Will you be discussing any major technical decisions or challenges encountered along the way?

Cristina Chumillas: Since the release of Drupal CMS 1.0 in January, we’ve made steady progress on defining the work that needs to be done to get Drupal CMS 2.0 and Experience Builder (XB) 1.0 ready for Drupalcon Vienna. The roadmap is being shaped by research, user feedback, and competitor benchmarking, ensuring a more accessible and marketer-friendly CMS while maintaining Drupal’s flexibility. Our approach will combine strategic planning, community collaboration, and expert-led decision-making. We’ll also go over several key challenges like, among others, improving UX despite limited resources, and increasing clarity around contribution priorities.

TDT[2]: Beyond roadmap updates, will your session explore how these developments impact Drupal users and developers? Are there any shifts in strategy or new approaches in the next version that attendees should be aware of?

Cristina Chumillas: Beyond roadmap updates, this session will explore how Drupal CMS 2.0 enhances the experience for both marketers and developers. A major shift is the platform’s increased focus on usability for non-technical users, offering a more intuitive admin experience, a faster time to market, and AI-assisted tools. These changes position Drupal CMS as a more competitive solution across enterprise and mid-market segments.

Looking Ahead

"One of the most exciting aspects of Drupal CMS 2.0 is the strategic alignment driving its development"

A key takeaway from our work so far is the unprecedented increase in contributions, which has been instrumental in making this progress possible. Additionally, major announcements at DrupalCon Atlanta will unveil new capabilities that will redefine how we build Drupal sites.

Gina Banyard

TDT[1]: Gina, in your session, you're exploring PHP’s type system in practice and its theoretical underpinnings. As developers, we often use types intuitively but rarely stop to ask what a type really is. Given that, how do you think understanding the formal concept of a type and subtyping relation can change or improve how we write and structure our PHP code day to day—especially in large codebases or open-source projects like Drupal?

Gina Banyard: It is important to remember that any value has a type, obviously integers and strings are types, but any class, enumeration, or interface is also a type. Moreover, a type communicates what operations are possible on a given value, so if we are given an int or a float we know we can do arithmetic operations on it, or if we have a valid postal address encodes as a class PostAddress we know we can ship goods to it.

There is this quote from Edsger W. Dijkstra that is a good mantra to keep when designing types (i.e. classes, interfaces, enums) which is:

The purpose of abstracting is not to be vague, but to create a new semantic level in which one can be absolutely precise.

This is one of the primary motivations for introducing value objects for postal addresses, names, emails, etc. because if a function (or method) that requires all of this information would simply accept 3 different string parameters it would be very easy to misuse the function and swap the order of parameters. Therefore using types, and ideally a static analysis tool, can eliminate a whole class of bugs even before running any code.

Intersection types, available since PHP 8.1, are a very useful feature for splitting up large interfaces into more meaningful, smaller interfaces. For example, over the past year, I have been working on reworking the ArrayAccess interface to split it up into a bunch more interfaces that would give a more granular indication of what sort of behaviour is actually supported by an implementing class.1

TDT[2]: As we know you’re discussing the Liskov Substitution Principle (LSP) and how PHP enforces it during inheritance—how strict would you say PHP really is when it comes to honouring LSP, especially compared to statically typed languages like Java or C#? And where do you think it still leaves room for missteps or misunderstandings among developers using inheritance and interfaces?

Gina Banyard: Prior to PHP 8.0 some LSP violations would only emit a warning (E_WARNING) instead of halting compilation.2 However, since then any LSP violation that can be detected at compile time halts compilation with a fatal error.

LSP is fundamentally about preserving behaviour and being able to swap one type (or implementation) with another one, and not have any consumers of said type break. It is usually described as 4 rules:

• Pre-conditions cannot be strengthened in the subtype
• Post-conditions cannot be weakened in the subtype
• Invariants must be preserved in the subtype
• History rule constraints must be preserved in the subtype

The first 3 are usually well understood as those impact the signature of methods and properties in subclasses. However, I think the most important one is the history rule even if it is usually omitted, because it cannot be checked by a compiler. The gist of it is that new methods in a subclass must not alter the state in ways that are not possible in the base class. This is generally why we say "composition over inheritance" and why protected members are considered "bad", as in the words of Bjarne Stroustrup (creator of C++):3

Members declared protected are far more open to abuse than members declared private.

It is very easy to hijack the state, and thus behaviour, of a protected property or method, in a way that violates the history rule.

Dr. Merlijn Sebrechts

TDT[1]: WebAssembly has traditionally been tied to browsers due to its JavaScript dependency. With WASI breaking that limitation, what are the most compelling use cases you foresee for WebAssembly beyond the browser—especially in web development and Drupal? As you’ll be covering this in your session, what key insights can attendees expect to take away?

Dr. Merlijn Sebrechts: I think there is a lot of value in using WebAssembly + WASI to improve the security of Drupal. More specifically, you could use it to limit the impact that a compromised plugin or library could have on your website. 

I'm not an expert in Drupal, so I can't talk much about Drupal specifics, but it seems that third-party plugins and libraries still can do a lot of damage in Drupal according to reports such as these: 3rd Party Libraries and Supply Chains - PSA-2024-06-26.4

WebAssembly + WASI gives you the tools to isolate each individual plugin and library and only give it access to the APIs it actually needs/uses. Moreover, WebAssembly can do this with minimal overhead. As a result, a compromised plugin will only have a limited impact on the rest of your website.

TDT[2]: With WASI enabling WebAssembly to run on microcontrollers, serverless platforms, and as a universal plugin format, do you see it competing with containerization technologies like Docker? Since your session will touch on WebAssembly’s potential in these areas, how should developers think about integrating it into their existing workflows, and in what scenarios would it be the better choice?

Dr. Merlijn Sebrechts: I think WebAssembly and docker containers will keep co-existing for a long time. Docker's advantage is broad compatibility with existing Linux applications. If your app runs in Linux, then it will probably run in Docker without any code changes. WebAssembly cannot give you that because it's not actually Linux. While some applications can be recompiled to WebAssembly without issue, others will require some code changes. 

Where WebAssembly shines, though, is for serverless computing and for platforms where Docker containers just don't fit. Docker containers are a bad fit for serverless computing because they are not very secure. As a result, most cloud providers still put every serverless function inside of a separate virtual machine!

"WebAssembly is a lot more secure, however, and we're already seeing some cloud providers switch from virtual machines to WebAssembly for serverless. This switch will only accelerate, because it's a lot cheaper for a cloud provider to run WebAssembly components compared to virtual machines" 

Thijs Suijten

Thijs Suijten, public speaker and technologist, gave us an overview of his upcoming session “Innovating for Impact: A Developer’s Role in Shaping the Future.”

In a world where technology shapes almost everything, Thijs invites developers to think about the broader impact of their work. From building open-source tools to deploying smart camera traps that help protect endangered wildlife, his keynote highlights real-world projects where code meets conservation. It’s a call to action—showing how developers can channel their skills into solving global problems, not just technical ones.

Drupal Developer Days 2025 brings together people who care about building better tools, solving real problems, and sharing what they’ve learned along the way. The keynote speakers are tackling topics that matter—from practical improvements in the CMS to deeper conversations about security, usability, and the role developers play in shaping what comes next.

Whether you’re attending to learn something new, connect with others, or just take time to think differently about your work, this year’s event offers space for all of that.