Dear Readers,

Over the past year, Drupal’s Certified Partner Program has made significant strides, adding 26 new companies and bringing the total to 101 Certified Partners. These partners played a crucial role in Drupal’s sustainability, sponsoring 87% of all contributions in 2024—a massive 158,387 issue credits out of 203,738 total contributions. But here’s the challenge: only 7% of the 1,440 active organizations on Drupal.org are Certified Partners, and just 15% of companies are responsible for 96% of all contributions. This imbalance threatens the long-term sustainability of Drupal, and we need to do more.  

As Tim Doyle outlines, Drupal's future depends on expanding its network of Makers—agencies and organizations that give back to the project rather than just benefit from it. The Drupal Association has set a bold new goal: tripling the number of Certified Partners and pushing for greater participation from larger companies that profit from Drupal but haven’t yet committed to contributions. At the same time, plans are in motion to reward high-level contributors and drive more business to those actively supporting Drupal’s future.  

This is a pivotal moment. With Drupal CMS creating new opportunities and the open-source landscape rapidly evolving, agencies must decide: Are we investing in the future of Drupal, or just relying on it? If your company builds with Drupal, now is the time to step up, contribute, and help shape the next chapter of the project.

Discover Drupal

• Drupal Trash Module: The Ultimate Solution for Managing Deleted Content
• Google Gemini Provider (beta): A Plugin for Drupal AI Module
• Drupal Sapiens Launches Scoring System and Rewards for Contributors

Security

• Drupal Releases Critical Security Updates to Address XSS, Access Bypass, and Gadget Chain Vulnerabilities

Event

• The Drop Times Joins DrupalCamp England 2025 as Media Partner
• Meet the Trainers Taking the Stage at Florida DrupalCamp 2025
• Meet the Minds Behind Florida DrupalCamp 2025: Conversations with the Speakers
• Support Inclusion at Drupal Mountain Camp 2025 with a Diversity Ticket
• Florida DrupalCamp 2025: Organizers Speak on Highlights, Preparations, and Community Spirit
• MidCamp 2025: Ticket Sales and Training Registration Now Open!

Organization News

• Palantir Preps EditTogether for Secure, Real-Time Drupal Collaboration
• LocalGov Drupal Introduces Certified Suppliers Program to Strengthen Council Collaboration
• Varbase 10.0.4: Incremental Update Rolls Out as Part of Release Cycle
• Morpht Enhances Convivial for GovCMS with Major Update
• Packagist Founder Urges Industry to Prioritize Open Source Funding

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 
Alka Elizabeth 
Sub-editor, The DropTimes.

Today we are talking about Drupal Contribution, how you can approach it within your company, and why a Contrib First approach is important with guest Steve Wirt. We’ll also cover Config Importer & Tools as our module of the week.

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

• What is contrib first
• How does this help the Drupal community
• Why is it a good idea for companies
• How do you explain this to non dev folks like CEOs or Presidents
• What do you say if a client does not buy in
• How do you monitor and build confidence in other developers
• How can someone get started
• Any tools or tips for someone trying to bootstrap this

• MOTW
  • https://www.drupal.org/project/confi
  • https://www.drupal.org/project/upgrade_tool
• Civic Actions Practice Tools - Contrib First
• Civic Actions Engineering Practice Area - Drupal Contrib First Module Development
• Codit menu tools
• Alt text validation - currently being built as Contrib First
• Bill requiring US agencies to share custom source code with each other becomes law
• Link shortners
  • http://dgo.re/ or https://dgo.to/ link shorteners for d.o
• Drupal Contrib Development
• Contribution to a module

Steve Wirt - civicactions.com swirt

Nic Laflin - nLighteneddevelopment.com nicxvan John Picozzi - epam.com johnpicozzi Avi Schwab - froboy.org froboy

Avi Schwab - froboy.org froboy

• Brief description:
  • Have you ever wanted to streamline the management of config changes during your Drupal project deployment - importing individual configuration changes from contrib or custom modules and synchronizing settings across different environments? There’s a module for that.
• Module name/project name:
  • Config Importer and Tools
• Brief history
  • How old: created in April 2016 by Andrii Podanenko(podarok)
  • Versions available: 3.2.0 version which works with Drupal 9 and 10, D11 fixes are in the queue.
• Maintainership
  • Actively maintained - although it’s a developer module that’s been mostly stable, so there have not been many recent changes.
  • Security coverage
  • Test coverage - unit tests
  • Documentation - video documenting the process on the module page and instructions in the project overview
  • Number of open issues: 8 open issues, 3 of which are bugs against the current branch
• Usage stats:
  • 300 sites
• Maintainer(s):
  • 7 maintainers across a few different agencies in Ukraine
• Module features and usage
  • This module has no UI, and all of its work is done using it’s config_import services, either importer or param_updater
  • The importer service imports full config files
  • The param_updater service pulls in single parameters from a config file.
  • Both can be used in .install files of contrib modules or on your own site to pull in configuration during database updates, which can be helpful for adding a new feature, modifying existing features, or pushing changes to many sites.
  • There is also a “spiritual successor” to the Confi module called “Upgrade Tool” which has similar functionality with some extra functionality too. https://www.drupal.org/project/upgrade_tool

DevCollaborative is a certified Drupal Partner, demonstrating our expertise in the space and giving back to the open source community that our business benefits from.

When it comes to building a website, two content management systems (CMS) often dominate the conversation: WordPress and Drupal. Both are powerful, open-source platforms with passionate communities, but they cater to different needs and skill levels. As someone who’s worked with both, I’ll break down their key differences—honestly—focusing on ease of use, flexibility, security, and cost, so you can decide which fits your next project best.

Ease of Use: WordPress Wins for Beginners

WordPress is the king of simplicity. With over 43% of the web running on it, its user-friendly dashboard, plug-and-play themes, and massive plugin library make it a go-to for bloggers, small businesses, and anyone who wants a site up fast. You don’t need to know code to get started—install a theme, add a few plugins like Yoast for SEO or WooCommerce for e-commerce, and you’re live in hours.

Drupal, on the other hand, has a steeper learning curve. It’s not that it’s impossible to use—it’s just built for developers or those comfortable digging into the backend. Setting up a basic site takes more time, and customizing it often requires familiarity with PHP, Twig, or its module ecosystem. If you’re not technical, Drupal can feel overwhelming, whereas WordPress feels like it’s holding your hand.

Flexibility: Drupal’s Power Shines

Where WordPress excels in accessibility, Drupal takes the crown for flexibility. It’s a CMS for complex, custom projects. Need a site with intricate user permissions, multilingual capabilities out of the box, or integration with enterprise-level systems? Drupal’s modular architecture lets you build exactly what you want, no compromises. Government sites, universities, and large organizations—like the White House or Harvard—rely on it for a reason: it bends to fit your vision.

WordPress is flexible too, but it leans on plugins to extend functionality. This can lead to bloat—too many plugins slow your site down or create compatibility issues. While WordPress can handle complex sites (think CNN or TechCrunch), it often feels like you’re jury-rigging it to match Drupal’s native capabilities. If your project is straightforward, WordPress is fine, for anything bespoke, Drupal’s the better bet.

Security: Drupal Edges Out Slightly

Security is where the debate gets spicy. WordPress’s popularity makes it a bigger target for hackers. It’s not inherently insecure—core WordPress is solid—but its vast plugin and theme ecosystem is a mixed bag. A poorly coded plugin or an outdated installation can leave you vulnerable. You’ll need to stay vigilant with updates and invest in security plugins like Wordfence.

Drupal has a reputation for being more secure out of the box. Its smaller market share (around 2% of websites) means fewer attacks, and its community is obsessive about patching vulnerabilities fast. Plus, Drupal’s built-in security features—like strict access controls and a focus on enterprise-grade standards—give it an edge for sensitive data. That said, no CMS is bulletproof, misconfigure either one, and you’re asking for trouble. Drupal just requires less babysitting.

Cost: WordPress is Cheaper Upfront, Drupal Pays Off Long-Term

WordPress is the budget-friendly option to start. Free themes and plugins abound, and hosting is dirt cheap—think $5/month on Bluehost. But costs creep up as you scale: premium plugins, developer fees for custom tweaks, and higher hosting for traffic spikes add up.

Drupal’s upfront cost is higher. You’ll likely need a developer to set it up, and hosting requirements are beefier (think VPS or dedicated servers over shared hosting). However, for large-scale sites, Drupal’s efficiency and lack of reliance on third-party add-ons can save money over time. It’s an investment: pay more now, maintain less later.

Performance: Drupal Scales, WordPress Needs Help

Out of the box, Drupal performs better under heavy loads. Its caching system (hello, Views!) and leaner core make it ideal for high-traffic sites with complex queries. WordPress can struggle here—without optimization (think caching plugins like W3 Total Cache or a CDN), it bogs down as traffic grows. For small sites, WordPress is snappy enough, scale up, and Drupal’s architecture shines.

Community and Support: WordPress Has the Edge

WordPress’s community is massive—forums, tutorials, and meetups are everywhere. Need help? Someone’s already solved your problem on Stack Overflow or a YouTube video. Drupal’s community is smaller but fiercely dedicated, with a focus on enterprise users. Documentation is top-notch, but it’s less beginner-friendly. If you’re DIY-ing it, WordPress support feels more accessible, Drupal assumes you know what you’re doing.

The Verdict: It Depends on You

Here’s the honest truth: neither is “better” in a vacuum. WordPress is perfect if you want a quick, affordable site with minimal fuss—think blogs, portfolios, or small e-commerce shops. Drupal is your pick for complex, custom, or high-stakes projects where control and scalability outweigh ease of use.  

If you’re a solo entrepreneur with no coding skills, start with WordPress. If you’re a developer building for a client with big ambitions (and a bigger budget), Drupal’s your tool. Both can get you there—it’s about matching the CMS to your goals, not forcing your goals into the CMS.  

What’s your take? Have a project in mind?

Share this

Add new comment

One of the most frequently performed actions in Experience Builder (XB) is inserting a component. That UI was moved to the sidebar last week to make it immediately available. After dragging a component onto the canvas, the most common next action is modifying the default component inputs.
So that’s precisely what Jesse Baker, Harumi “hooroomoo” Jang, Luhur Abdi “el7cosmos” Rizal and Lauri “lauriii” Timmanee iterated on this week:

Robust component previews

While modifying a component’s inputs (in the “Settings” tab in the right sidebar you can see above), the preview updates live. This is a crucial part of the XB user experience.
However … Single Directory Components (SDC) can completely fail to render if/when the values assigned to an SDC’s props (i.e. what you typed into that “Settings” tab) are not yet valid. For example: if you managed to type “http” but not the rest of a URL, then that is not a valid URL.
It’s up to XB to not attempt to not update the preview as long as the Content Creator-entered values for a component (currently only SDCs, more later) are not yet valid.

This is the problem Ben “bnjmnm” Mullins, Ted “tedbow” Bowman, Jesse and I fixed after Travis Carden first noticed this. Ben led the development of the solution: performing client-side validation, using both HTML5 client-side validation (used by some Drupal field widgets) and JSON schema validation (which is possible for all SDC props). Once that infrastructure is present, it’s quite simple: don’t update the preview until the input is valid.
Fun fact: XB was using the uri field widget, which uses <input type="url">. That comes with automatic strict absolute URL client-side validation. We had to switch to the link field widget instead.

An obvious consequence: sometimes the preview doesn’t update as fast anymore. So far we’ve found this to not be really noticeable, for two reasons. First, the used field widgets are shaped to disallow invalid values as much as possible (for a type: string, enum: […], you’ll see radio buttons, for example, eliminating the possibility of invalid values altogether). Second, the inputs whose values are “most difficult” to be valid tends to be URLs, and either those URLs aren’t directly visible (in links), or they’re highly visible (images, videos) and it intuitively makes sense those can’t appear until the full, valid value is present anyway.

Missed a prior week? See all posts tagged Experience Builder.

Goal: make it possible to follow high-level progress by reading ~5 minutes/week. I hope this empowers more people to contribute when their unique skills can best be put to use!

For more detail, join the #experience-builder Slack channel. Check out the pinned items at the top!

Blocks, continued

Last week, initial support for Blocks landed, so this week two continuations of that initial support landed:

• Felix “f.mazeikis” Mazeikis, Dave “longwave” Long and I enabled the thorough validation that landed 4 weeks earlier for Block-sourced components, and given it was now thoroughly validated, it became possible to reliably enable support for rendering entire pages using XB’s page variant!1
  Interesting tidbit: to avoid changes elsewhere in the XB codebase, we had to use PHP Fibers — available since PHP 8.1 — to achieve this. 🤓
• Dave and I added support for derived block plugins, which means that for example one “menu block” per menu is also available in XB, as you’d expect

Grab bag

• Dave, Jesse and Ted fixed a pretty silly bug: it became impossible to drag a component in between two other components! 😅
• Jesse tightened TypeScript definitions (discovered last week while working on section saving). This helps keep out development pace high.
• Also to keep the pace high: our end-to-end test suite always started with the same single article node with a prepopulated XB component tree. This made sense originally, because it literally was first possible to have a server-side-stored component tree and render it, and only then was the UI built to allow a Content Creator to build such a component tree.
  We’ve long since reached that point, so it was about time we added an end-to-end test that starts with an empty canvas. Thanks, Ted & Ben!
• Issue #3484671 by longwave, wim leers: Add support for block derivatives — https://git.drupalcode.org/project/experience_builder/-/commit/fdbbd78d9b6e4f8de0b650fc46643fc5bbc57d6b

Week 27 was November 11–November 17, 2024.

• 1

  That means it can now render the “main content”, “page title” and “messages” blocks!

A new website as easy to navigate as the airport itself

Tampa International Airport consistently ranks #1 in customer satisfaction thanks in part to how easy it is to navigate. Our goal of the redesign of tampaairport.com was to make sure their Drupal 10 website was just as easy to maneuver. Their team wanted to level up their website’s airport map from simple and static to interactive and dynamic.

React application with Drupal content management

The application's goal was to fetch data from the newly implemented site, providing users with a tool to easily navigate the airport, search for specific locations, and even order food in advance at airport restaurants and cafes. The decision to build a React application stemmed from its performance and ability to integrate with the Drupal site, enabling site editors to consolidate, manage, and edit all content through the Drupal UI. This approach ensured that content updates could occur dynamically without the need for additional development efforts, setting up their team to sustain the custom map.

Recognizing that the primary users of this application would be on mobile devices, we worked hard to ensure that all JavaScript libraries and node packages were lightweight and optimized for mobile performance. 
We significantly reduced the overall footprint of the React application before integrating it into the Drupal site by leveraging techniques like code splitting, which separates components that can be loaded independently, and tree shaking, which removes unused code when bundling multiple JavaScript files. This reduced package size ensures a more efficient experience for users accessing the app on their mobile devices.

React Leaflet library

From a technology standpoint, the application is built using React Leaflet, a library that establishes connections between React and the open-source Leaflet JavaScript library.  The incorporation of Leaflet enables us to display custom images, replacing traditional geographical maps within the interface. To dynamically display our SVG maps, we utilize the ImageOverlay component using map information provided by our custom API endpoint provided by Drupal. We use memoization at the location level so that when users switch between maps, the application swiftly recalls previously viewed layers, ensuring a seamless and responsive experience.

Leaflet provides us with the flexibility to set our own boundaries for the map layer. In this application, we opted for a 1000 by 1000 base grid. Within the Drupal UI, editors have the ability to effortlessly add new map locations by specifying X and Y coordinates, effectively placing locations on the map within the established grid.

Furthermore, editors can easily customize the displayed map icons and manage the inclusion of locations within specific icon groupings, all through the user-friendly provided UI. This streamlined process empowers editors to make dynamic adjustments to the map without the need for additional development support.

Interactive user experience

The application also includes a list view of the map in which users can select specific locations, triggering a seamless navigation experience on the visual map. Each location in the list displays details such as their name, description, business hours, current status, and proximity to airport gates. Upon choosing a location, the application responds by centering the corresponding point on the visual map.

This interactive feature enhances user experience, allowing them to effortlessly explore and locate points of interest without manually searching the entire map. The linkage between the list view and the visual map ensures that users can easily transition from browsing a curated list of locations to visually identifying and locating those places on the map interface. It serves as an intuitive method to guide users from the textual representation of locations to their spatial representation on the visual map.

Notably, the list view was designed with accessibility in mind, ensuring better usability for keyboard and screen reader users. This thoughtful implementation caters to a diverse range of users, making it an inclusive and user-friendly experience for all. Check it out for yourself.

The collaboration between the Drupal and React technologies allowed us to build a solution that seamlessly meets the needs of both users navigating the maps and the editors on the Tampa International Airport team. Even though creating this map from scratch was a blast, the custom application I built could easily be applied to another client’s map or way-finding tool.