Drupal Planet

You've probably seen some excitement in the Drupal community around Experience Builder. The current version (0.5.0-alpha1) shows a giant leap forward in Drupal's page building and editing experience.

Since late 2024, I've been engaged by Acquia to work on Experience Builder. This has been a particularly challenging project, combining many core Drupal concepts, such as the Form, Render, Entity, Plugin and Validation APIs, with newer front-end technologies like React, Redux, RTK-Query, Vite and Astro.

As we approach a beta release, I've been thinking about how we could push Experience Builder even further. Here are some of the things I'd love to work on next.

Currently, Experience Builder makes use of hashing to detect editing conflicts. If two users are editing the same page and one of them doesn't have the latest changes, the back end will prevent a user from overwriting another user's changes. This is similar to the 'The content has either been modified by another user, or you have already submitted modifications' error message we've had on content edit forms for a long time.

Unfortunately, this doesn't align with what users expect in 2025. Users are accustomed to multi-user editing experiences, such as Google Docs. Experience Builder has gone to great lengths to focus on building a modern front-end editing experience with React, so getting a 'reload to fetch latest changes' message detracts from that.

Luckily, we're well-positioned to support a multi-user workflow.

In Experience Builder's front-end, when you make a change to the page, you making use of Redux to keep track of the layout and model. Each change triggers a 'reducer' that takes the old state and returns a modified version of it.

Currently, we perform those changes on the front-end and then make either a PATCH or POST request to Drupal to update the preview and store the draft version. When you edit a single component, we make a PATCH request and update only that component.

When you perform any other operation, such as re-ordering a component, deleting a component, or adding a new component, we perform a POST request and update the entire model. Technically, in REST parlance, this is a PUT, but let's not split hairs.

True collaborative editing applications typically use a collaborative editing algorithm. There are two widely used algorithms and a third emerging one.

• Operation Transformation (OT)
• Conflict-free Replicated Data Type (CRDT)
• Event Graph Walker (EG Walker)

Google Docs uses the OT algorithm. It has low memory and storage requirements, but is slow to perform merges. CRDTs are more efficient when it comes to merging, but have higher data storage and memory requirements. EG Walker is an emerging algorithm that combines the best of OT and CRDT, aiming to reduce the data and memory overhead of CRDTs without losing the merge speed.

Because we use reducers to make changes to the front-end, we're already thinking of updates to the model as discrete operations. This should lend itself well to adopting a true collaborative editing algorithm that will allow us to achieve the multi-user editing experience users expect in 2025.

Currently, the front-end polls the back-end every 10 seconds to update the list of pending changes. This is because we don't have a way of initiating updates from the server side.

Mercure is a lightweight real-time event server that uses Server Sent Events. Mercure was created by Kévin Dunglas from the Symfony Core team and easily integrates with PHP (there's even a module for it).

Adding real-time events to Experience Builder unlocks a huge number of usability improvements. Not only can we initiate updates from collaborative editing in real-time, we can also get really creative with the user experience and add features like:

• Multi-user presence notifications - e.g. we could show the Avatar of users editing a page in the top bar, which is what Google Docs does
• Highlight components another editor is editing - we could add a visual indicator to a component when another user is editing it

Obviously, we would need to take a progressive enhancement approach to this. We can't make Mercure a hard requirement for hosting a Drupal site. We could add these features when Mercure is available and configured, and silently ignore them when it isn’t.

At present, Experience Builder does a round-trip back to Drupal to update the preview. This is because for SDC and block components, we need Twig to render the preview. Ideally, we could generate a preview from the user's browser and avoid this latency.

There are two ways we could tackle this.

The first approach is to ship a WASM running Twig. The Twig playground is an in-browser version of Twig that lets you write and execute Twig code. This utilises a WASM running PHP and Twig. If we took this approach, we could likely achieve a feature set very close to that of running Twig in Drupal. Obviously, there are some things we can't do. We would be limited to pure Twig templates that take input and produce output. Modules like Twig Tweak, which let your Twig templates interact with Drupal, couldn't be supported. Luckily, most of the things we're rendering in Experience Builder should largely be pure, such as SDCs and Blocks.

The second approach is a bit more experimental. In my spare time, I've been working on a library called twigCASTer. It takes the token stream parsed from Twig and turns it into a Component Abstract Syntax Tree. The Twig parser is only interested in tokens that it needs to render the output. It takes no position on the hierarchy of HTML. Markup in Twig files is seen as a string, with no context of the DOM tree it may represent. twigCASTer extends Twig tokens to build up a DOM tree whilst parsing the string content. From there, it can be cast into another component language. I've been experimenting with taking this AST and casting it into valid compiled JSX. 

It’s still very early days, but I do have a number of test-cases passing where Twig goes in and valid JSX, ready for consumption in the browser, comes out. This is a much more ambitious approach and will be tricky to get right. An obvious shortcoming of this approach would be many Drupal Twig extensions that have no JSX equivalent.

Are you interested in working on any of these features? Do you have ideas or experience working with the technologies mentioned? Reach out in the Experience Builder channel. Or are you interested in sponsoring work on these features?  Get in touch with us to express your interest.

Today we are talking about Drupal Hooks, why they got changed in core, and what to do now with guest Karoly Négyesi better known as Chx. We’ll also cover Media Folders as our module of the week.

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

• Deep Dive into Drupal Hooks
• The Evolution of Drupal Hooks
• Challenges and Solutions in Hook Conversion
• Community Involvement and Contributions
• The Future of Drupal Hook System
• Introduction to Procedural Hooks
• Understanding Theme Hooks
• Complexities of Preprocess Hooks
• Converting Hooks to Object-Oriented
• Impact on Contributed Modules
• Challenges in Core Conversion
• Future of Drupal Hooks
• Lightning Round and Conclusion

• Hooks becoming OOP
• Convert everything everwhere all at once
  • Conversion script
  • Conversion patches
• Ordering hooks OOP
• Preprocess hooks
• Render API change
• 2009 issue for form api ungrokable
• 2007 change for calling themes hook
• Giant issue with all of the hook related links
• Longest hook in core: entity_query_tag__entity_test_mulrev__entity_query_entity_test_mulrev_alter_tag_test_alter

Károly Negyesi - ghost-of-drupal-past

Nic Laflin - nLighteneddevelopment.com nicxvan John Picozzi - epam.com johnpicozzi Martin Anderson-Clutz - mandclu.com mandclu

Martin Anderson-Clutz - mandclu.com mandclu

• Brief description:
  • Have you ever wanted to have your Drupal site's media assets presented in a UI that evokes the hierarchy of a filesystem? There's a module for that.
• Module name/project name:
  • Media Folders
• Brief history
  • How old: created in Apr 2025 by João Mauricio (jmauricio)
  • Versions available: 1.0.3 which supports Drupal 10.3 and 11
• Maintainership
  • Actively maintained
  • Security coverage
  • Test coverage
  • Number of open issues: 9 open issues, 2 of which are bugs, although one was just fixed
• Usage stats:
  • 61 sites
• Module features and usage
  • The module mimics a file structure by associating media entities with a taxonomy hierarchy
  • It then provides an intuitive, drag-and-drop UI to move items between locations, drag in new items, or even search within a particular “folder”, including a recursive search
  • When you drag in files, it uses “smart” logic to automatically assign files to Media bundles
  • It provides a form display widget, a view display widget, a CKEditor plugin, and it’s compatible with other filesystem modules, like S3 File System
  • This kind of interface is a requirement I’ve seen in RFPs by companies looking for a new CMS, so having this available as a drop-in solution

DrupalCon has always been a conference by the community, for the community—and as we look ahead to DrupalCon North America 2026 in Chicago, we’re making thoughtful changes to ensure it continues to reflect those values.

After a successful DrupalCon Atlanta, we’ve taken time to reflect, gather feedback, and make updates that prioritize access, sustainability, and community connection.  Each of the changes outlined below is rooted in one or more of these values—whether it's improving affordability, building lasting relationships, or creating a more efficient and inclusive event experience. With guidance from the DrupalCon North America Steering Committee, we’re excited to share a refreshed ticket structure, updated volunteer policies, a reimagined Expo Hall, and a renewed focus on summits, trainings, and collaboration.

We’ve simplified and lowered the cost of general admission tickets to make DrupalCon more accessible—without sacrificing the quality of experience our community expects. These changes were driven by feedback from past DrupalCon attendees, the North American Steering Committee, and the community at large, all of whom expressed a strong desire for more affordable access to the event.

Early Bird registration opens September 15, 2025 and is open for 16 weeks!
Secure your ticket early to lock in the best rate.

For every 5 tickets purchased from a Drupal camp or local association, that community will receive 1 complimentary ticket to share with a deserving community member, with a max of 10 complimentary tickets per local camp or association. It's our way of reinvesting in local leadership and participation.

This change reflects our focus on access and sustainability. In our DrupalCon Atlanta recap blog, we highlighted how streamlined operations improved the event experience for attendees and volunteers alike. Building on that momentum, we recognized the need for clearer guidelines to ensure volunteer opportunities are distributed fairly and effectively.

We’ve updated the volunteer ticket structure to make it more equitable and scalable:

• Volunteer under 20 hours → 25% discount
• Volunteer 20+ hours → Complimentary ticket

These tickets are non-transferable and may not be combined with other discounts.

Previously, volunteer ticket codes were sometimes misused or distributed without proper oversight. These updated guidelines help preserve full complimentary tickets for those who contribute a significant amount of time and effort, while also creating new opportunities for others to attend at a reduced rate.

Additionally, we’ve streamlined the on-site registration process with self-check-in, reducing the need for a large number of on-site volunteers and allowing us to focus support where it’s most impactful.

Learn more and sign up to volunteer.

Summits are one of DrupalCon’s most valuable opportunities for industry-specific collaboration and knowledge sharing. Designed to connect attendees working in the same verticals, these events offer focused access to speakers with real-world experience, engaging roundtable discussions with peers in similar roles, and meaningful conversations about shared challenges. Attendees walk away with practical takeaways and lasting connections, while participating sponsors have a chance to introduce themselves to leaders in the space in an organic, relevant way.

Taking place Monday, 23 March 2026.

Join peers in:

• Healthcare
• Higher Education
• Government
• Nonprofit
• Community

Each summit features two half-day sessions that do not conflict with the main conference program, creating space for meaningful discussion and idea sharing.

Lunch is not included with the Community Summit, but a lunch ticket add-on will be available for purchase during registration.

DrupalCon Trainings remain at $500 and offer deep-dive, expert-led learning opportunities on a wide range of Drupal skills.

You’ll notice more networking spaces, and informal meeting zones—especially in the Expo Hall and hallways. We’re doubling down on meaningful, unstructured connections.

These changes are only possible through thoughtful cost management and the continued support of our sponsors. Their partnership helps us keep ticket prices accessible while delivering the high-quality experience the community expects. We’re grateful to those who invest in DrupalCon and help us create an event that welcomes and supports everyone.

The Drupal Association is happy to issue official invitation letters for those requiring a visa.

Request your visa letter here.

Letters are generated automatically—just complete the form and check your email (including spam folders).

Hilton Chicago is DrupalCon’s official headquarters hotel—and it's where the magic happens.

From morning coffee chats to late-night strategy sessions in the lobby, this is where the community connects. Staying on-site helps you maximize your time, make spontaneous connections, and be part of the full experience.

Book your room at the Hilton Chicago.

We’re reimagining our sponsorship offerings to better connect you with the Drupal community—bringing fresh opportunities and updated packages designed for greater visibility, value, and impact.

Want to be the first to know when they go live? Email [email protected] and we’ll make sure you're on the list.

DrupalCon is more than just a conference—it’s the beating heart of our community. These changes help us keep that heart strong, inclusive, and accessible.

We can’t wait to see you in Chicago, 23-26 March 2026. 

Drupal conferences are always rich with technical insights for building exceptional digital experiences. But there's another side — the non-technical topics that are just as essential. These themes resonate deeply with anyone working in tech (and beyond), because without them, even the best technical skills aren't enough to build truly great websites. Just as importantly, they help us navigate life’s complexities, stay resilient, and maintain a sense of balance.

Every part of Drupal, from modules to core releases to translations, is built and maintained by people. Thousands of contributors shape this ecosystem: writing code, reviewing issues, reporting bugs, maintaining projects, improving accessibility, updating documentation, mentoring others, and supporting discussions. Much of this work happens quietly, without being seen beyond issue queues, commit logs, or Slack threads. Yet this invisible layer is what keeps Drupal alive and moving forward.

Drupal has always valued community, and it already has a strong culture of contribution. The credit system, contribution recognition on Drupal.org profiles, and core commit messages all reflect that. But there’s room to show more. Not just who contributed to the core, but who maintains projects that thousands of sites depend on. Who keeps the modules stable? Who takes the time to help others in forums? Who steps in when no one else does? These are not side efforts; they are part of what makes Drupal reliable.

Recognising this work more clearly, whether through module pages, community spotlights, contributor highlights in newsletters, or dashboards that show project health, can strengthen the whole ecosystem. It supports trust. It helps people build reputations. It encourages sustained involvement. It reminds everyone that Drupal is not just made of code—it’s made of people who care, and continue to show up. As the project evolves, creating more ways to acknowledge and celebrate that effort is a simple, powerful step forward.

• What Noah’s Page Builder Just Quietly Solved in Drupal—And Why It Matters

• Using Automated Testing Kit in Your Project - Part 2

• Drupal Launches Proposal for Trusted Site Template Marketplace

• Drupal 10.5.1 Released with Bug Fixes and Security Reminder for Site Owners

• Secret Login Module Introduces Secure URL and Token-Based Access for Drupal

• Marvin Parsons Advocates One-Week Headless Drupal Deployment

• Boost Drupal Performance with New Partytown Integration Module

• TDT's Chinju Prakash Wins Kerala Sahitya Akademi Award for Translation

• Axelerant Introduces MACH Architecture with Headless Drupal 11 and Next.js

• Tag1 Brings Apache Solr 8.x and 9.x Support to Drupal 7 with D7ES Update

• Lullabot Wins 2025 Netty Award for Tech Company of the Year

• Drupal Business Survey 2025 to Present Global Market Trends at DrupalCon Vienna

• Call for Speakers – Pacific Northwest Drupal Summit Deadline July 11, 2025

• Volunteer Opportunities Now Open for DrupalCon Chicago 2026

• DrupalACT July 2025 Meetup in Canberra Features Vue Web Apps on Drupal

We acknowledge that there are more stories to share. However, due to selection constraints, we must pause further exploration for now.

To get timely updates, follow us on LinkedIn, Twitter and Facebook. You can also join us on Drupal Slack at #thedroptimes.

Thank you, 
Sincerely 
Kazima Abbas
Sub-editor, The DropTimes.

Our work began well before the formal announcement of the AI Initiative. Drupal Developer Days, in April, for example was a focused week of meetings, healthy debate, collaboration and consensus building which laid the foundations for the Initiative. 

Much has already been achieved in raising awareness of Drupal AI. Thanks to the efforts of James Abrahams, Marcus Johansson, Frederik Wouters and many others, there is already a strong body of material in place — including high-quality presentations, conference talks, and resources such as workflows-of-ai.com — all showcasing the capabilities of Drupal AI.

With the announcement of the Drupal AI Initiative, comes support from The Drupal Association, permission to create pages on Drupal.org in prominent locations, agency to scale marketing efforts. Part of the backing offered by the 6 founding companies of the AI initiative is resources to deliver marketing, both time and money. This is already starting to deliver tangible results.

In the beginning the team consisted of Frederik Wouters (Drop Solid) and myself (1xINTERNET). Immediately following Drupal Dev Days we started creating content for the new landing pages, working with Dries on the announcement video, collaborating with designers at 1xINTERNET to produce supporting imagery. In parallel staff from all the initiative founding companies were preparing exhibition stands, printed materials and social media in preparation to exhibit at AI Summit London.

In the meantime James Abrahams (Freely Give) and Dries were preparing for the launch of the Drupal AI webinar series in partnership with the EC. Following the resounding success of the Drupal@Europa Web Platform Hackathon, the European Commission agreed to host a webinar series which will be run by our team, the first recording of which is available to watch on YouTube. Be sure to register for the upcoming webinars in the series.

Literally the day after the AI Initiative launch, we were heading for London to showcase Drupal AI at AI Summit, a leading business-focused conference on artificial intelligence, held annually as part of London Tech Week. Our exhibiting supports objectives of The Drupal Association to see Drupal's profile raised at major marketing and digital industry events globally.

Together with colleagues from Drop Solid, Freely Give, Amazee.io, 1xINTERNET, the Drupal Association and Acquia, we came together with a shared purpose to represent Drupal AI at this event. It brought together stakeholders from government, the public and cultural sectors, and enterprise, all exploring how AI can be meaningfully integrated into their organisations.

We took the opportunity to capture some interviews introducing the AI Initiative and to explain how the focus it brings will see momentum in Drupal taken to another level.

Our aim is to run regular Webinars to help keep the community aware of our progress, educate and raise awareness amongst potential customers and end users of the potential of Drupal AI offers. This month we organised our first webinar, an AMA aimed towards Drupal community members. You can access a recording and read highlights here.

With the launch announcement completed, we have now established weekly meetings on Monday 17:00 BST to accommodate our growing and global team. We’d love to have you join us. If you would like an invite, please drop us a message on #ai-initiative-marketing Slack, which is our primary collaboration channel.

We are pleased to now have several active contributors to the marketing team including: 

• Matthew Saunders (matthews)
• Kristen Pol (kristen pol)
• Lenny Moskalyk (lenny-moskalyk)
• Jason Lewis (jason-lewis)
• Maggie Schröder
• Alan Botwright
• Jennifer Griffin Smith
• Owen Milbury
• Nick Koger (nkoger)
• Matt Wetmore
• Frederik Wouters (wouters_f)
• myself (pdjohnson)

You can get a sense of the work we have planned in the AI Initiative issue queue. These are particularly well suited to anyone seeking to make non code contributions including content creation, marketing strategy, media outreach, project management, community affairs. There is plenty to do, we are happy to mentor and onboard new contributors. Start your journey today!

Photos: Paul Johnson available on Flickr (AI Summit, Drupal Developer Days)

"We'll add the tests later". Most of us have said this at some point in our software development career. But then "later" never arrives.

That is because implementing tests is hard. Setting up the test runners, writing the test cases, keeping them running; all of it requires extra effort. Even more effort is needed for end-to-end tests (E2E) since they touch every part of an application. However, this effort always pays off and in this post, I will share how we implemented end-to-end tests (E2E) on one of our Drupal projects so that you can save some of the effort needed to get started. We are very happy with how this approach turned out and we plan to use it on future projects too.

ILO Live is the International Labour Organization (ILO)'s online video streaming platform. It hosts both live streams and recordings of events organized all across the world by the ILO.

Under the hood, ILO Live is powered by Next.js and a headless Drupal CMS. Most pages on the site are statically served by Next.js.

In this post, I will take you through how we implemented E2E tests on ILO Live.

A common approach when writing frontend tests is to use mocked API responses. But with ILO Live, we wanted to go a step further and use the actual CMS in the tests. By using the actual CMS in the tests, in addition to verifying whether the site works as intended, we can also verify whether changes to the CMS have not caused any functionality on the site to break. But to do this, we had to solve 2 major problems.

1. How do we orchestrate the CMS into different testing states from the test runner?
2. How do we quickly start the CMS during each test run?

The simplest way to orchestrate a Drupal CMS is to have a test runner click on various elements to create new entities and change their state. But this takes a lot of time to run, especially when multiple entities need to be created during each test run.

To solve this problem, we decided to create a private API using the JSON-RPC module. This API would only be enabled on development and testing instances of the CMS and it exposed several operations which the test runner could use to orchestrate the CMS into different states.

For example, the JSON-RPC API exposed a create.event method for creating new events.

And a clean.content method for resetting the CMS to the initial state with no content set.

We added similar methods for creating other entities on the site and for admin tasks such as reindexing the search index. ILO Live used AWS AppSync to receive real-time updates about the current state of events so to simulate this in the tests, we set up a testing instance of AppSync and implemented methods like the update.livestream method shown below to change the state of this instance.

Now we had to get the Drupal CMS to run while the test runner was running. We were familiar with using Cypress for implementing frontend tests so we decided to use the same for implementing the E2E tests. Since the E2E tests ran assertions on elements on the site / frontend, we decided to store the E2E tests within the frontend repo and use Github Actions to run them since the frontend repo was hosted on Github.

We used GNU Make and Docker Compose during development to run the CMS and its services (i.e. Maria DB and Redis) so initially we tried to clone the CMS and run the commands to start it. Docker is preinstalled by default on the ubuntu-latest runner on GitHub Actions so we were able to easily use it there.

This setup worked but it took around 2 - 4 minutes to run. Most of this was due to Composer and the Drupal site install.

This delayed each test run so we started looking into ways to improve it. The solution that we came up with was to create a self-contained Docker image for the Drupal CMS. This way, the test runner only needed to pull and run a single image to start the CMS.

To do this, we set up a Github Actions workflow on the CMS repo to build and push a development Docker image. This image had the JSON-RPC API enabled and it used a SQLite database instead of MariaDB.

We used the Configuration Split module by our own Fabian Bircher to ensure that the JSON-RPC module is only enabled during development.

Here is the Github Actions workflow we used to build and publish the image to the Github Container registry.

This is the updated workflow on the frontend repo for using the development image.

With this setup, the development image is built within 5 minutes each time a pull request is merged into the develop branch of the CMS and the E2E tests workflow can start the CMS in less than a minute.

An added benefit of this approach is that it was much simpler to run the CMS. Previously, the only way to run the CMS was to clone the CMS repo and set up the project locally alongside the database server. Now it just needed a single command.

To use the JSON-RPC API more conveniently within the Cypress tests, we defined several Custom Commands.

These custom commands made it much easier to orchestrate the CMS as required.

Ultimately we implemented over 50 end-to-end tests for this project. The final test suite takes between 7 - 8 minutes to run on a standard Github hosted runner. (i.e. Not a large runner) This runtime is acceptable for us for now but it can be improved even further by using Parallelization.

While these tests took us some effort to implement, they definitely paid off in the long term. ILO Live had live event functionality which was mission-critical but very hard to orchestrate manually and with the E2E tests, we were able to ensure that it always worked. These E2E tests gave us the confidence to make big improvements to the codebase since we knew that bugs in key functionality would be instantly revealed and this is the biggest benefit of them all.

Written by Prabashwara Seneviratne, frontend developer at Nuvole and author of Frontend undefined.

Upgrading your Drupal site from version 10 to 11 is a great way to keep your website secure, fast, and ready for the future. Drupal 11, released in August 2024, brings exciting features like improved performance, a modernized user interface, and updated APIs for seamless integration with modern technologies.

The transition from Drupal 10 to 11 is smoother than past major upgrades, thanks to Drupal’s semantic versioning. This guide walks you through the process with practical steps to ensure a seamless upgrade.

Before diving into the steps, let’s explore why upgrading matters. Drupal 11 offers:

• Enhanced Security: Stricter API access controls and automatic updates keep your site safer.
• Better Performance: Optimized caching and faster database queries mean quicker page loads.
• Modern Features: Updates like CKEditor 5’s autoformatting, Symfony 7, and single directory components (SDC) make content management and development easier.
• Future-Proofing: Drupal 10 support ends in mid-2026, so upgrading now keeps you ahead.

Preparation is key to a smooth upgrade. Here’s what to do:

• Back Up Everything: Save your codebase, database, and files using tools like Drush (drush sql-dump) or your hosting provider’s backup feature. Test the backup to ensure it’s restorable.
• Update to Drupal 10.3+: Drupal 11 requires at least Drupal 10.3.0. Run composer update drupal/core-recommended --with-dependencies to update.
• Check Hosting Requirements: Ensure PHP 8.3+, MySQL 8.0+, MariaDB 10.6+, or PostgreSQL 16+. Note that Microsoft IIS is not supported.
• Audit Your Site: Remove unused modules, themes, or content to streamline the process.

Drupal 11 removes deprecated modules and updates dependencies. Ensure compatibility with these steps:

• Install Upgrade Status Module: Use composer require drupal/upgrade_status and run drush upgrade_status:analyze. Check the report at Admin > Reports > Upgrade Status.
• Update Contributed Modules: Run composer update and verify module compatibility on Drupal.org.
• Review Custom Code: Use Drupal Rector (composer require --dev palantirnet/drupal-rector) to fix deprecated code.
• Handle Removed Modules: Install contributed versions of removed core modules (e.g., Statistics) to preserve functionality.

Never upgrade on a live site. Create a staging environment:

• Clone Your Site: Copy your codebase and database to a separate server or local environment.
• Test Functionality: Ensure all features work as expected before proceeding.

With your site prepped, follow these steps:

1. Grant Write Permissions:
    

   chmod 777 web/sites/default chmod 666 web/sites/default/*settings.php chmod 666 web/sites/default/*services.yml

2. Update Core with Composer:
    

   composer require 'drupal/core-recommended:^11' 'drupal/core-composer-scaffold:^11' 'drupal/core-project-message:^11' --no-update composer require 'drush/drush:^13' --no-update composer update

3. Run Database Updates:
    

   drush updb -y drush cr -y

4. Export Configuration:
    

   drush cex -y

5. Revert File Permissions:
    

   chmod 755 web/sites/default chmod 644 web/sites/default/*settings.php chmod 644 web/sites/default/*services.yml

Test your site in the staging environment:

• Check key functionalities (forms, views, content types).
• Verify custom and contributed modules.
• Test across browsers and devices.
• Review the status report (Admin > Reports > Status) for errors.

Once tested, deploy to production:

• Back up your production site.
• Deploy the updated codebase and database.
• Run drush updb -y and drush cr -y.
• Monitor for issues.

• Composer Errors: Use composer why-not drupal/core 11.0.0 to identify dependency issues.
• Missing Modules: Install contributed versions of removed core modules.
• Custom Code Issues: Check module issue queues or Drupal forums for manual fixes.
• Performance Hiccups: Optimize caching settings post-upgrade.

Upgrading from Drupal 10 to 11 is manageable with careful planning. By updating to Drupal 10.3+, auditing modules, fixing code, and testing thoroughly, you’ll minimize risks. The result? A faster, more secure site ready for Drupal 11’s modern features.

Need more tips on securing your Drupal site? Explore our security guide to keep your site safe post-upgrade.

Have questions or tips about Drupal upgrades? Share them in the comments below!

Welcome to the July 2025 DDEV Newsletter
This month: Downgrading Terminus for old PHP, FrankenPHP, Advisory Group meeting and Governance proposal, Shopware Storefront and Admin Watchers, Writing your first Drupal 10 Functional Test, and more.

• How to Downgrade Terminus in DDEV's Web Container and Customize Other Bundled Tools
  A guest blog by Bill Seremetis explaining the problem with an old PHP version and Pantheon's Terminus, and how to fix it. → Read more↗
• Experimenting with FrankenPHP in DDEV
  Stas Zhuk explains two ways to use FrankenPHP in DDEV. → Read more↗
• July 2025 DDEV Advisory Group Meeting meeting notes and recording! → Read more↗.

• From DevOps Headaches to Seamless Onboarding: How Dropping Chocolatey Made DDEV the Perfect Fit for a Client's Drupal Team → Read more↗
• Shopware Storefront and Admin Watchers with DDEV → Read more↗
• How to Write Your First Functional Test in Drupal 10 → Read more↗

• Apache Foundation-inspired Project Management Committee Exploration
  See a proposed early update to the DDEV Foundation's Articles of Incorporation, aiming us at governance like the Backdrop CMS folks have → Details↗

• Monthly average income down slightly from $7,809 to $7,759 (65% of $12,000 goal). Every contribution helps sustain our work—thank you! → Become a sponsor↗

• Blog↗
• LinkedIn↗
• Mastodon↗
• Bluesky↗
• Discord↗

At its core, the Drupal AI Initiative is about helping organisations adopt AI responsibly. As Paul Johnson put it:

“We’re looking to tell the amazing story of how Drupal AI can help organisations that want to adopt AI that is safe and in a way where freedom remains to make their own choices.” - Paul Johnson

The group shared updates on work happening in AI Core, including modules for agents, logging, testing, and a new Experience Builder that aims to make page creation smarter without compromising on security or trust.

“I’m not a programmer myself. Everything we've done with AI we’ve tried to build in a way that analysts, PMs, even content editors can make use of.” - Jamie Abrahams

Attendees asked important questions, and were answered transparently:

• Funding: Smaller agencies raised concerns about staying competitive in a rapidly evolving AI space. The group discussed options like the Makers funding program and collaborative approaches to share costs.

• Safe adoption: Several participants asked how to keep up with AI’s breakneck pace while avoiding dead-ends. The consensus: stick to open standards, contribute upstream, and share what works.

• Contribution paths: For developers and marketers alike, there are plenty of ways to get involved, from writing documentation to building modules to promoting best practices. Join the Drupal AI Marketing Weekly to pitch in.

“Most important, we are here to listen to your feedback.” - Baddy Breidert

All the slides from the session are available here. You’ll also find handy links:

• Drupal AI Strategy PDF

• Starshot AI Initiative page

• Developer Docs

• Connect with Dominique or Jamie to get hands-on.

• Watch the recording: Welcome to the Drupal AI Initiative

• Join the conversation: Hop into the AI issue queue, Slack channels, or reach out to the working group.

• Stay tuned: More sessions, training, and contribution sprints are on the way, including the Drupal GovCon AI training and hack-a-thon later this year.

This initiative will only succeed if it’s shaped by the whole community. If you care about building a safe, open, and innovative Drupal AI ecosystem. Your input matters.

“Please stay tuned for the upcoming webinars and upcoming news.” - Lenny Moskalyk

And See you next time!

In 2025, Drupal continues to evolve as a powerful, open-source content management framework that balances flexibility, scalability, and extensibility. As we prepare to gather in Vienna a city rich in both culture and innovation, this year's DrupalCon is more than a conference. It's a comprehensive reflection on how Drupal has matured over the years, where it stands today, and where it’s headed next.

Drupal’s Origins: Laying the Foundation for Open Web Platforms

Drupal began as a simple message board over two decades ago, yet its architecture was built on a vision of extensibility and community collaboration. What started as a hobby project grew into a full-fledged CMS adopted by developers, governments, universities, and enterprises around the globe.

From the early introduction of modules and hooks to the groundbreaking adoption of Symfony components and modern PHP standards, Drupal's architecture has consistently prioritized maintainability and reusability. The rise of the Form API, Entity API, and Configuration Management System laid the groundwork for scalable content-driven applications.

Key innovations in the early years:

• Introduction of a modular system enabling rapid extension of core functionality
  
   
• The evolution from procedural to object-oriented code structures
  
   
• Strong community governance and open contribution models
  
   

These early decisions positioned Drupal as a future-ready framework long before terms like "composable DXP" or "headless CMS" entered the mainstream.

Drupal Today: Engineered for Modern Digital Operations

In 2025, Drupal is no longer just a CMS, it's a backend digital experience engine that powers mission-critical applications across sectors. Its flexibility has enabled it to adapt to a changing landscape of decoupled front ends, API integrations, and marketing automation.

• API-First Design: Drupal 10 and 11 offer robust REST, JSON:API, and GraphQL support out-of-the-box, making integration with JavaScript frameworks and external services seamless.
  
   
• Advanced Content Modeling: With custom entities, paragraphs, taxonomy systems, and fieldable content types, teams can represent structured and reusable data at any scale.
  
   
• Decoupled and Progressive Decoupling: From fully headless implementations to progressively enhanced Twig-based front ends, Drupal supports a spectrum of architectural patterns.
  
   
• Multisite + Multilingual: Multisite capabilities combined with flexible language modules enable the deployment of global, multi-brand, and localized content ecosystems.
  
   

• Government: Role-based access control, WCAG compliance, multilingual content management, and enterprise security protocols are supported natively, making Drupal ideal for secure and accessible government portals.
  
   
• Enterprise Marketing: Marketers and developers benefit from multisite capabilities, flexible editorial workflows, and seamless integration with CRM, DAM, and analytics tools — all critical for omnichannel delivery.
  
   
• Education & eLearning: Institutions leverage Drupal as the core CMS for AI-assisted platforms that recommend content, track learning progress, and personalize student engagement through decoupled UIs and custom APIs.
  
   

This modular and composable architecture enables Drupal to function not only as a website builder but also as the integration layer between diverse enterprise systems.

Looking Ahead: Drupal’s Technical Roadmap

As we look beyond Drupal 10 and 11, the project continues to invest in modernization and developer experience. The core roadmap emphasizes:

• Enhanced Admin UI: React-based administrative themes and improved UX for non-technical users
  
   
• Automatic Updates: Secure and stable auto-updates for core and contributed modules
  
   
• Project Browser: A visual interface to discover, install, and evaluate contributed modules from within the admin UI
  
   
• Better Decoupling Support: Continued investment in GraphQL schemas, real-time data synchronization, and rendering decoupled menus/navigation
  
   
• Developer Tooling: Improved DX through Composer support, API stabilization, and increased PHP type safety
  
   

Community initiatives such as GitLab CI/CD integration, increased test coverage, and standardization around frontend tooling (Webpack, Vite, etc.) are also helping push Drupal closer to being a developer-first platform without sacrificing editorial ease-of-use.

 Join the Evolution in Vienna

DrupalCon Vienna 2025 offers a rare opportunity to immerse yourself in the full journey of Drupal from its humble origins to its role in powering complex, enterprise-grade applications. Whether you're a backend architect, frontend engineer, digital strategist, or platform lead, there’s something for everyone.

What to expect:

• Sessions from core maintainers and initiative leads
  
   
• Hands-on workshops for developers transitioning to decoupled and API-first builds
  
   
• Real-world architecture case studies from large-scale Drupal implementations
  
   
• Opportunities to contribute to the Drupal project and shape its future
  
   

 Why It Matters

In a world where digital transformation is no longer optional, Drupal continues to prove its value by being adaptable, secure, and deeply rooted in the principles of open collaboration. Its future depends not just on the technology, but on the people contributors, builders, and thinkers who continue to push the platform forward.

At DrupalCon Vienna 2025, you won’t just learn about where Drupal has been. You’ll help shape where it’s going next.

🗓️ Dates: October 14–17, 2025
 📍 Location: Austria Center Vienna, Vienna, Austria
 🌐 Official Website & Registration: https://events.drupal.org/vienna2025/registration-information
 🐦 Follow the buzz: #DrupalConVienna #DrupalCon2025

This blog is just the beginning. Over the next few weeks, I’ll be sharing:

• Technical spotlights on Drupal CMS features
• Speaker highlights and session previews
• Tips for first-time technical attendees and contributors
  
   

So bookmark this space, and get ready to experience DrupalCon Vienna 2025 like never before.

Are you coming? Let’s connect!

By Iwantha Lekamge

Technical Lead
WSO2

The ecommerce industry is already undergoing a new revolution with marketplaces helping the customers to discover a variety of sellers which they can access on a single platform.

Approximately 30 percent of the total purchase orders on the internet across the world are made via online market platforms. 

And that is the nutshell actually; why not take a chance when your brain child could be the next disruptor!

After watching my enterprise client’s Drupal developers lose hours every week wrestling with raw Docker Compose for local development, I championed a switch to DDEV, the open‑source tool that gives “container superpowers with zero required Docker skills” (ddev.com). One of the snags on their Windows laptops was the Chocolatey package manager, whose install path clashed with locked‑down corporate security policies. Working with DDEV maintainer Randy Fay, I removed the Chocolatey dependency, paving the way for a leaner installer that shipped in version 1.24.5. Development team members now onboard much quicker, and leadership can point to measurable productivity gains.

My client’s legacy workflow relied on a bespoke Docker Compose stack. Developers routinely diverted time to babysit containers as well as copying their work in and out, instead of writing code. This echeos industry findings that more than 58% of engineers lose 5‑plus hours per week to “unproductive work”. This DevOps overhead impacts their developer experience (DX), which is a distraction from their actual work.

DDEV abstracts all that Docker plumbing with simple commands (e.g. ddev start, ddev stop) while still running everything locally. Its promise, “environments in minutes, multiple concurrent projects, and less time to deployment”, resonated immediately.

A Drupal codebase is never just PHP; it drags along Composer, Drush, front‑end toolchains, and database snapshots. DDEV’s predefined Drupal preset provides a reproducible stack with Nginx/Apache, MariaDB, and Mailhog out of the box.

The developers work on locked‑down Windows laptops. DDEV’s install script used the Chocolatey package manager, which corporate policies block from writing to its default location. Workarounds involved various hurdles, exactly the sort of DevOps toil they wanted to eliminate.

While in research mode, I discovered Issue #6636, maintainers themselves wanted to drop Chocolatey but hadn’t had the bandwidth to do so. I volunteered a pull request that:

• removed Chocolatey from the installation process, and
• no longer required an Administrator Powershell; an unprivileged user could install it in a terminal.

The patch was merged on April 10, 2025.

A month later, the change landed in v1.24.5 with a shout‑out in the release notes: “Chocolatey removed from automated Windows installation scripts. Thanks to @colans.” It’s now simpler for Windows developers to install DDEV, and they don’t have to be an administrator.

“Container superpowers with zero required Docker skills” isn’t just marketing. Here’s the quantified rationale I presented:

1. Zero Docker config: ddev start replaces hand‑rolled Compose files.
2. No central registry maintenance: Images build locally.
3. Host‑level commands: ddev drush status or ddev composer install without docker exec.
4. Unified file system: The code lives on the host, eliminating copy‑in/out cycles.
5. Safe rebuilds: Deleting containers never loses work.
6. Always‑on Git: blame, diff, and branch with the active code without stepping into the container.
7. First‑class Composer: Composer‑managed Drupal is just a ddev composer require away.

• Onboarding time dropped from half a day (or more) to an hour (or less).
• Additonal support for broken sandboxes fell to nearly zero.
• Developers now focus on development, not troubleshooting containers, or moving code in and out of them.

I’d like to thank Randy Fay for prompt code reviews, patient feedback, and for shepherding the change into a release.

Head to the official DDEV installation documentation and give it a spin. And if you’re stuck on Windows, it’s now much easier to install.

The PHP ecosystem is changing fast, with tools like FrankenPHP improving both performance and developer experience.

FrankenPHP is now officially supported by The PHP Foundation.

This guide explains two ways to integrate FrankenPHP, based on my experience.

You can either run FrankenPHP as a separate service (lets you install extra PHP extensions) or inside DDEV's web container (uses a static binary without support for extra extensions).

This blog shows examples of the recently added DDEV's generic web server, which supports flexible configurations. It allows you to use any custom web server you want, including Node.js, Python, Ruby, etc.

I created the stasadev/ddev-frankenphp add-on to experiment with FrankenPHP as a separate service with some additional features:

• Ability to install PHP extensions (Redis, Xdebug, SPX, etc.)
• Better resource isolation

To add PHP extensions (see supported extensions here):

• Standard Linux and DDEV tools are installed in the web container, not in the frankenphp container.
• See the add-on README for adding Xdebug (ddev xdebug does not work here).
• Enabling or disabling Xdebug requires rebuilding the frankenphp container.
• ddev launch does not work because the web server runs in a different container.

If you want to suggest some feature or found a bug, feel free to open an issue.

Alternatively, FrankenPHP can be run inside the web container. This example from the DDEV quickstart shows a setup (for a Drupal 11 project) where FrankenPHP is added as an extra daemon.

• It's not possible to install additional PHP extensions (requires ZTS build).
• Limited debugging capabilities, ddev xdebug doesn't work.

• FrankenPHP documentation
• DDEV's generic web server
• FrankenPHP add-on
• FrankenPHP quickstart
• Hola FrankenPHP! Laravel Octane Servers Comparison: Pushing the Boundaries of Performance

Using ddev-frankenphp-benchmark, I compared three setups:

• nginx-fpm: DDEV's nginx-fpm web server with php-fpm
• generic-web: DDEV's generic web server with FrankenPHP inside the web container (static binary)
• generic-addon: DDEV's generic web server with FrankenPHP inside the frankenphp container (with pdo_mysql extension)

Summary:

• All configurations delivered comparable and adequate performance.
• FrankenPHP is a win where there is an upstream hosting environment using FrankenPHP.
• Benchmarks used default DDEV settings, not production-optimized configurations.
• Laravel Octane (FrankenPHP worker mode) was not used and could yield better results.
• CPU and memory usage were not measured.

Software:
DDEV: v1.24.6
Mutagen: disabled
PHP: v8.4
Laravel: v12.19.3
FrankenPHP: v1.7.0
Docker Engine: v28.3.0
Operating System: Manjaro Linux AMD64
Kernel Version: 6.12.35-1-MANJARO

Hardware:
Intel i7 8750H (6 Core/12 Thread, 2.2 Ghz, Turbo 4.1 Ghz)
32 GB DDR4 2667 Mhz
Samsung 870 Evo SSD (530w/560r MB/s)

If you find DDEV (and its add-ons like FrankenPHP) useful, consider supporting its development. Thank you!

Exploring DDEV, LAMP, and Local Server for Drupal 11

Drupal 11 offers API-first features and enhanced performance, making the choice of development environment critical.

I’ve worked with DDEV, LAMP, and Local Server setups like XAMPP or MAMP to assess their strengths.

This guide delivers a detailed breakdown with setup instructions, configuration options, practical examples, and a comparison table, serving as a resource to match your project needs.

A solid development environment is essential for Drupal 11 projects. The sections below provide in-depth details on DDEV, LAMP, and Local Server, based on my hands-on experience.

DDEV is the official local development tool for Drupal, built on Docker and supported by the community, with documentation at https://www.drupal.org/docs/official_docs/local-development-guide.

• Setup Process: Install Docker from docker.com following OS-specific instructions (download and CLI setup), create a Drupal project with composer create-project drupal/recommended-project my-site navigate to the directory with cd my-site initialize with ddev config (set docroot to "web" and PHP version, e.g., 8.1), start with ddev start.
• Configuration Options: Edit .ddev/config.yaml to add custom domains, multiple databases, or integrate tools like MailHog for email testing, adjust PHP versions or enable extensions via the YAML file.
• Practical Applications: Used on a 12-site project, configuring custom domains and databases in the YAML file, added SSL for local development to mirror production.
• Considerations: Requires learning Docker basics (a few hours), needs 4GB RAM minimum (8GB recommended), configuration changes may need community forum support.

Try tweaking config.yaml to set PHP versions, enable Xdebug for debugging, or add services like Redis based on your project requirements.

LAMP, made up of Linux, Apache, MySQL, and PHP, is a traditional stack offering detailed control, widely used for Drupal development.

• Setup Process: Use a Linux distro like Ubuntu, update the system and install Apache with sudo apt update && sudo apt install apache2, install MySQL with sudo apt install mysql-server and secure it with mysql_secure_installation install PHP 8.1+ and modules with sudo apt install php8.1 php8.1-mysql php8.1-cli php8.1-mbstring.
• Configuration Options: Create a virtual host file (e.g., /etc/apache2/sites-available/drupal.conf) with DocumentRoot set to your Drupal directory, enable it with sudo a2ensite drupal.conf restart Apache with sudo systemctl restart apache2 tweak .htaccess or MySQL settings for performance.
• Practical Applications: Built a small news site, optimizing .htaccess for caching and MySQL queries, required manual load balancing as traffic hit 600 users daily.
• Considerations: Setup can take a day due to dependency issues, updates and security patches are manual, scaling needs additional infrastructure like reverse proxies.

Consider adding phpMyAdmin for database management and Drush 12 for automating tasks like cache clears or module updates.

XAMPP and MAMP provide a pre-configured bundle of Apache, MySQL, and PHP, ideal for quick local development, especially for beginners.

• Setup Process: Download XAMPP from xampp.org or MAMP from mamp.info, run the installer for your OS (Windows, macOS, Linux), start Apache and MySQL via the control panel, place Drupal 11 files in htdocs (XAMPP) or htdocs (MAMP) and access at http://localhost (15-20 minutes total).
• Configuration Options: Adjust ports (e.g., Apache to 8080) in the control panel if conflicts occur, enable PHP extensions like mysqli or gd through the configuration interface.
• Practical Applications: Prototyped a client portfolio site in under an hour, required port changes for a second site, showing limits with multiple projects.
• Considerations: Not suited for large sites (lag with 50+ pages), port conflicts possible with other apps, requires at least 2GB RAM, with older hardware struggling over time.

Check the control panel for port adjustments and review PHP error logs (in htdocs/logs) to troubleshoot setup issues.

This table compares DDEV, LAMP, and Local Server across key development factors based on observed performance.

• Ensure PHP 8.1+ is active—verify with php -v.
• Keep Composer current—run composer update regularly.
• Always back up before changes—use drush archive-dump to save your work.

DDEV, LAMP, and Local Server each bring unique capabilities to Drupal 11 development, from community-driven consistency to hands-on control or rapid setup. This guide aims to equip you with the knowledge to choose what fits your goals. Take your time to assess your project’s scale, team needs, and resource availability—your decision will shape the foundation of your work.

Your website is at risk. Drupal 7’s end-of-life is looming, leaving sites open to attacks, while CMSs like WordPress or Joomla struggle with bloat or scalability limits. 

These outdated systems drive users away—think single-page visits from Drupal Planet—costing you engagement and revenue. Migrating to Drupal 11 is your escape plan, offering top-notch security, blazing performance, and modern features. 

This no-nonsense guide gives businesses, developers, and individuals the clear steps to transition from Drupal 7 or another CMS, fast and hassle-free.

Clinging to an outdated platform is like ignoring a check-engine light—disaster’s coming. Drupal 11 delivers faster load times, a sleek Claro admin theme, and API-first flexibility, keeping users hooked and your site secure.

• Drupal 7 Users: With legacy Drupal 7 support ending, unpatched vulnerabilities threaten your site. Drupal 11 offers robust security and modern UX.
• Other CMS Users: WordPress’s plugin chaos or Joomla’s rigid structure can’t match Drupal 11’s power for dynamic content or headless setups.
• Real Impact: A retailer migrated from Drupal 7 to Drupal 11, cutting load times by 25% and boosting conversions by 18%.

Quick Action: Audit your site with Security Review (Drupal 7) or WPScan (WordPress) to spot risks. Visit our Migration Resource Centre for more.

This playbook breaks down the migration process into five clear steps using Drupal’s Migrate API and community tools. No fluff, just results.

Avoid data loss and compatibility issues with solid preparation.

• Drupal 7: Install Upgrade Status module to check module compatibility. Backup with Backup and Migrate: drush bam-backup.
• Other CMSs: Export content via WordPress’s Tools > Export or Joomla’s Akeeba Backup. Map content (e.g., WordPress posts to Drupal articles).
• Outcome: A news site cut migration risks by 50% with thorough backups.
• Beginner Tip: Use our Drupal Migration Guide for a prep checklist.
• Pro Tip: Document custom fields for smoother mapping.

Create a clean Drupal 11 environment to receive your content.

• Install Drupal 11: composer create-project drupal/recommended-project my-site.
• Enable Migrate modules: drush en migrate migrate_drupal migrate_tools -y.
• Outcome: A developer saved 20% setup time with Composer.
• Beginner Tip: Choose a Drupal-ready host for quick setup.
• Pro Tip: Test on a staging environment first.

Move your Drupal 7 content seamlessly.

• Use Migrate Drupal UI: Go to Structure > Migrations to import content, users, and taxonomy.

• Custom fields: Create a module for complex data (e.g., paragraphs).

  # my_migration.migration.node.yml id: custom_node source: plugin: d7_node node_type: article destination: plugin: entity:node process: title: title body: body
• Test: Run drush migrate:import custom_node --update.
• Outcome: A university migrated 10,000 nodes in 48 hours, no data lost.
• Beginner Tip: Use Migrate Drupal UI for no-code migrations.
• Pro Tip: Monitor progress with drush migrate:status.

Switch from WordPress, Joomla, or others with ease.

• Install WordPress Migrate: composer require drupal/migrate_wordpress.
• Map fields: WordPress posts to Drupal articles, categories to taxonomy.
• Outcome: A blog moved from WordPress to Drupal 11, boosting SEO by 15%.
• Beginner Tip: Use Feeds module’s UI for drag-and-drop imports.
• Pro Tip: Validate imports with a small dataset first.

Make your site fast, SEO-friendly, and engaging.

• Rebuild URLs with Pathauto:

  # pathauto.pattern.article.yml type: canonical pattern: '[node:content-type]/[node:title]'
• Enable caching: Configuration > Performance > Enable Page Cache and BigPipe.
• Audit content: Use Content Moderation for review workflows.
• Outcome: An e-commerce site cut bounce rates by 20% with optimized URLs.
• Beginner Tip: Install Pathauto via admin UI for easy setup.
• Pro Tip: Track engagement with Google Analytics Reports module.

Migration isn’t just about survival—it’s about thriving.

• Business: A retailer migrated from Drupal 7, gaining 30% faster load times and 18% more conversions. See our EXARC case study.
• Developer: A Joomla site moved to Drupal 11, saving 40% in build time. Explore our blog for optimization tips.
• Blogger: A WordPress user switched to Drupal 11 with Feeds, growing engagement by 25%. Visit our Migration Resource Centre.

Avoid these common mistakes to ensure a smooth migration:

• Data Loss: Backup with Backup and Migrate before starting.
• Incompatibility: Check module compatibility on Drupal.org.
• Performance: Optimize database: drush sql:optimize.

Quick Action: Download our Drupal Migration Guide to dodge these pitfalls with a full checklist.

Don’t let an outdated site hold you back. Drupal 11 offers the security, speed, and flexibility to keep users engaged. Start with our Drupal Migration Guide or learn more about managing legacy Drupal 7 sites. Need tailored help? Contact us or check our blog for more Drupal tips. Nonprofits can explore our discounts.

• Migration Resource Centre
• Managing Legacy Drupal 7 Sites
• EXARC Case Study
• Drupal Tips on Our Blog
• Nonprofit Discounts