Submitted Sessions

At Evolving Web, we built a new visualization tool for GRID (Global Repository of Income Dynamics), an application that serves 300+ economic statistics through a fully dynamic react interface powered by shadcn and Highcharts. This talk breaks down the architecture behind it: how a config-driven system combined with a small hierarchy of variable classes lets the app generate its UI, controls, chart logic, and constraints automatically, without hardcoding a single dropdown or visualization rule.

I’ll show how we structured the app so new datasets, view modes, and visual behaviors can be added by editing configuration instead of touching components. You’ll see how polymorphism handles different data types, how the factory pattern keeps everything consistent, and how this approach eliminates repetitive code while making future data growth trivial.

This presentation teaches job seekers and professionals how to turn their LinkedIn profile into a high-performance lead-generating asset. It covers the essential strategies for improving visibility, credibility, and engagement so recruiters and hiring managers come to you. The session also breaks down how to structure your profile for stronger outbound success—meaning your messages get seen, opened, and replied to. Attendees will learn practical tactics for optimizing their headline, About section, experience, skills, and activity, along with proven techniques for crafting outreach that earns responses. By the end, participants will understand how to position themselves effectively, attract more opportunities, and increase their success in today’s competitive job market.

Aegir is a powerful open-source system that automates the full lifecycle of Drupal sites—provisioning, cloning, upgrading, backing up, and more. This session introduces the basics of how Aegir works, including platforms, site management, and the task-driven system that makes large-scale Drupal hosting far easier and more consistent.

We’ll look at what Aegir does well, how it fits into modern Drupal workflows, and why it continues to be a valuable tool for freelancers, agencies, and anyone responsible for multiple Drupal sites.

We’ll also touch on the current hurdles Aegir faces with Drupal 11+, especially around Drush and key architectural changes. These issues can create challenges today, but active work is underway to address them and keep Aegir moving forward.

This session is designed for anyone curious about what Aegir can offer and how to start using it effectively.

Learn how to set up and manage Drupal sites locally using DDEV. This session will cover the benefits of containerized local development, tips to streamline your workflow and common pitfalls to avoid. Perfect for developers looking to save time and improve productivity.

Organizations rush to implement AI but see minimal ROI by treating it as a feature rather than a fundamental shift in how teams work. This gap costs companies millions in wasted licenses and missed opportunities.

This session cuts through the hype to show our proven approach for developing AI-powered solutions that integrate seamlessly with existing enterprise systems. We'll demonstrate real tools built for clients, including Tessera—our AI solution that transforms project management by intelligently generating comprehensive Jira epics, issues, and tasks from high-level requirements.

You'll see how we leverage Elvex for integration orchestration, n8n for workflow automation, and modern AI technologies to create maintainable, scalable systems. This is battle-tested methodology from enterprise development trenches, covering architecture decisions, integration patterns, and practical considerations separating successful implementations from expensive experiments.

Live demonstrations show these tools connecting with Drupal APIs and content management systems, but principles apply to any enterprise platform. You'll learn to evaluate AI use cases, design robust architectures, create intuitive interfaces, and maintain systems in real-world environments using approaches you can implement immediately.

A demo deep dive on CSS variables, and how they can be leveraged to make your components more configurable and reusable. We'll explore inheritance, typing, composability, the JavaScript API, and other scary-sounding but actually not too bad concepts that reduce development effort and increase component utility. Supercharge your components with CSS custom properties!

This session will provide step-by-step guidance on how to edit and add text formats, to customize the behavior of Drupal's formatted text entry fields. You'll learn about the problems they can help you solve, the pitfalls to avoid, and how to troubleshoot problems you might encounter.

We'll also cover some ways that Drupal modules can extend the capabilities to make life easier for your content editors.

Many of us are still using standard Drupal to build websites for clients instead of Drupal CMS, but one of the really great enhancements in Drupal CMS is the inclusion of pre-configured contributed modules.  Even today, I'm seeing Drupal sites launched without the most basic configurations in CKEditor,  Media and other "quality of life" configurations and  Drupal CMS fixes most of that.

In the session, we'll explore the modules that are installed in Drupal CMS and why you should include them in your standard Drupal 11 website.  Some of them will be very familiar and some may be new to you!

Are you still spending more time fixing your local environment than actually building Drupal sites? Does "it works on my machine" sound like a scary phrase to your team?

In this session, we will dive into modern local development using DDEV. We will move past the basics of installation and explore how to create a consistent, reproducible, and fast development workflow that mirrors production.

We will cover:

• The Quickstart: Spinning up a Drupal 10/11 site in under 5 minutes.
• Tooling Integration: Using Composer, Drush, and Xdebug without installing them on your host machine.
• Team Consistency: How to share configuration files so every developer on your team has the exact same environment.
• Performance: Tips for making Docker and DDEV run faster on Mac, Windows, and Linux.

Whether you are a solo freelancer or part of a large agency, this session will help you reclaim your time and focus on what matters: writing code.

Security and privacy compliance certifications—like SOC 2 (a leading audit standard for security, availability, and confidentiality) and HITRUST (a healthcare-focused security framework) — are becoming requirements for healthcare, finance, and other high-trust industries. Waiting until audit season to start to prepare can be overwhelming.

This session shares engineering-side lessons from Encore Healthcare’s journey to SOC 2 and HITRUST readiness. Instead of a checklist of requirements, we’ll focus on designing systems, processes, and documentation so you’re always ready to provide evidence to an auditor. We’ll walk through how we integrated compliance into our SDLC, infrastructure, access control, logging, and team processes—what worked, what didn’t, and the pitfalls we wish we’d avoided.

You’ll leave with a blueprint for making security compliance part of your natural engineering workflow, not a stressful scramble.

Learning Objectives

By the end of this session, attendees will be able to:

1. Apply engineering practices (SDLC, logging, IaC, access control) that generate audit-ready evidence automatically.
2. Perform internal reviews (onboarding checklists, policy adherence, vendor management) that reduce last-minute compliance gaps.
3. Develop a practical plan for working with consultants, clarifying ambiguous audit requests, and avoiding common pitfalls in SOC 2/HITRUST readiness.

Target Audience

• Engineering leaders and senior developers responsible for compliance-sensitive Drupal applications
• DevOps and infrastructure teams preparing for SOC 2 or HITRUST
• Technical managers balancing product delivery with compliance requirements

Prerequisites

• Familiarity with modern software development practices (version control, CI/CD, IaC)
• Experience operating Drupal or other SaaS/web applications in production
• No prior compliance experience required — this is about engineering preparation, not legal fine print

Have you been writing JavaScript to do things on the web and wondered if there was a better way? Fear not, CSS and HTML are here to ease your JavaScript woes! I'll go over a few new and upcoming CSS and HTML attributes, elements, and APIs that eliminate the need for JavaScript, such as:

• The Invoker Commands API
• The Popover API
• Anchor positioning
• View transitions
• Scroll driven animations
• and more!

Learn how to use the newest HTML and CSS techniques to replace excessive JavaScript and improve performance using the latest web native technologies.

The Events module is a useful tool for Drupal camp event-organizers to schedule featured speakers, customized sessions, and event job listings to the various sponsors. 

What is the best way to begin creating an automated test script for a contributed module? How do you go about making a standardized and enterprise standard test for you to contribute, apply, and share with your own organization? 

There are many steps in the process of making a useful automation test for your contributed module, so you can save time in testing and improve your test driven workflow toward a site feature you consistently work with.  

This session will go over the common practices that are used from: developing a test with targeting the right elements in your script, to refactoring your test script to code-standards, as well as ensuring generic application and test reliance as well. 

Discover how you can improve your existing testing workflow, contribute your own test to the Drupal work space, and use automated testing for your existing modules within your team.

AI-powered coding tools like Claude Code, Cursor, and Copilot are transforming how developers work, but many Drupal developers find that the hype doesn't match their experience. These tools often feel better suited for suggestions and troubleshooting than for writing Drupal code directly. There's a reason for this: LLMs are trained on the contents of the internet, and popular frameworks like React have vastly more example code in that training data. The result is an "AI gap" where some teams are dramatically accelerating their output while others struggle to see the same benefits.

The good news is that Drupal developers can close this gap without abandoning what makes Drupal great. Drupal remains unmatched for content authoring and management, and its rich ecosystem of API modules makes it a natural fit for powering decoupled frontends. By combining Drupal's backend strengths with a React frontend, you position your team to take full advantage of what AI tools do best: writing components, generating tests, and iterating rapidly.

In this session, I'll introduce a framework that pairs Drupal Recipes with React components to create modular, full-stack building blocks. You'll see a live demo of deploying a component that installs a Drupal Recipe and generates the corresponding React component using GraphQL and Next.js, with AI handling frontend tasks in real time. Attendees will leave with a practical decoupled strategy and access to the framework to explore with their own teams.

Ever feel like requirements gathering produces documents nobody reads, leaving developers guessing what stakeholders actually want? Or ship a feature only to hear "that's not what I meant"? 

There's a better approach: collaborative workshops where stakeholders, developers, and testers work through concrete examples together—defining requirements in plain language that become your automated tests. No more translation gaps between what's requested and what's built.

In this session, you'll learn a workshop technique called Example Mapping that transforms vague feature requests into clear, testable requirements. We'll walk through how these examples written in plain language flow directly into automated tests using Behat and Behavior Driven Development (BDD), turning those examples into tests that automatically confirm you built the right thing.

What you'll learn:

• Learning how to facilitate a collaborative requirements workshop with your team
• Using the four-color card system (stories, rules, examples, questions)
• Writing examples in plain language that everyone can understand
• Translating examples into automated test scenarios for Behat
• Integrating this testing approach into your Drupal development workflow
• Real-world examples from Drupal projects

Who should attend:

This session is for developers, project managers, business analysts, and anyone involved in defining or building Drupal features. No prior testing experience required.

Almost a year ago, we launched the IXP Program to solve a challenge every Drupal community member knows: talented newcomers can't get hired without experience, but can't gain experience without someone taking a chance on them. This program embodies Drupal's values of "Better together" and "Prioritize impact."

This session shares real outcomes from putting community values into action: 5 new developers connected with 3 companies, delivering over 1500 contribution credits. IXP participants mastered content management, created custom modules, implemented DevOps practices, and contributed meaningfully to Drupal.org modules.

Rather than theoretical frameworks, you'll learn from both our victories and challenges—the practical reality of building sustainable talent development that works for newcomers, organizations, and the entire Drupal ecosystem.

When I wrote about pricing ourselves out of Drupal projects, that led me to explore how Kubernetes orchestration could transform development team coordination.

Here's what I learned from moving beyond the original pricing problem. We evolved from simple "guidance" ideas to systematic orchestration that addresses multiple market challenges: offshore communication breakdowns, unsustainable pricing, and the false choice between quality and cost.

I'll present the systematic orchestration framework we're developing. Complexity-driven resource allocation that matches task requirements to developer expertise. Four-tier coordination systems that maintain quality while optimizing costs. Partnership frameworks that solve these problems through technical architect mediation.

This framework challenges broken industry economics by building systematic solutions to coordination problems.

If recognizing the value of neurodiversity is the first step, the next is changing systems, environments, and behaviours to actually support neurodivergent people. Neuroinclusive spaces use the ethos of Universal Design.

Universal design (UD) is a concept that involves designing products and environments to be usable by as many people as possible, regardless of age, size, ability, or disability. The goal is to maximize usability without the need for specialized design or adaptation. UD can be applied to many things, including buildings, services, tools, learning strategies, and physical spaces. It focuses on equity in design.

This session will move beyond why neurodiversity matters and focus on how to operationalize inclusion at every level of an organization, from hiring, to team culture, to leadership practices.

It offers practical strategies for building neuro inclusive organizations by applying the principles of Universal Design to workplace systems, culture, and leadership. Participants will learn how to identify hidden barriers and implement changes that foster clarity, flexibility, and psychological safety for all minds.

Neuroinclusion isn’t about fixing people, it’s about fixing systems.

Learning objectives

• Recognize systemic barriers that neurodivergent people face in hiring, learning, and workplace environments. Most importantly, how these often go unnoticed.
• Apply Universal Design and neuro inclusive practices to support diverse cognitive styles, communication preferences, and working needs.
• Implement practical strategies that foster clarity, flexibility, and psychological safety while creating environments where all minds can thrive.

With git worktree it's easy to have multiple versions of your Drupal project checked out into different directories.

And DDEV has a special feature to let you have the name of the project be determined by the directory it's in.

So you can have the same git repository checked out 5 places and all 5 of them (with different features or bugs or whatever) running at the same time.

This is surprisingly easy and pretty mature stuff. Take a moment with it and we'll have fun!

When you need to discover a regression, it's great to know when it happened! It's surprisingly easy to do with git bisect - You can find out what commit had a regression, and in the process you'll learn how to think carefully about how to define and solve the problem. 

We'll cover:

• How simple it is to do the basic git bisect to find out when something went wrong
• How to do fancier things (like a composer install at the point of a piece of code, or a database import)
• How to make a simple script that will do all the work while you're having coffee or sleeping

It's easy. Take the little bit of time to master a great tool.

Drupal Canvas introduced Code Components in early 2025, opening a new avenue for Drupal frontend engineering by shipping a zero-setup, in-browser code editor, and out-of-the-box support for React and Tailwind CSS. A lot has happened since then. As the technical lead for Code Components, I've watched the possibilities steadily grow as Drupal Canvas has matured and become stable.

New features have been introduced to support data fetching and Next.js-style image optimization. Experiments are underway to support server-side rendering and third-party imports. Editing Code Components is no longer bound to the browser: A CLI tool makes it possible to work with them in any development environment. This opens up interesting opportunities, such as building decoupled frontends.

This session will discuss different approaches and techniques for working with Code Components in Drupal Canvas, as well as the current state of all features, experiments, and plans for the future.

Mystified about the role that fields play in modern Drupal? Still working on wrapping your head around terms like "entities", "bundles", and "fields"?

This beginner-level session will focus on one of the core building blocks of Drupal - its ability to add fields to (almost) anything. You'll get a birds-eye view of the role that fields play in the content architecture of a Drupal site, and leave with a better understanding of how both core and contrib modules can leverage this important building block of Drupal.

Drupal 10.3 quietly introduced a powerful new tool for handling complex access control: the Access Policy API. And if you missed it, you’re not alone.

Roles have always been Drupal’s primary tool for granting permissions. But as projects grow more complex, teams often end up battling role explosion — creating more and more narrowly-defined roles just to capture specific business rules. And when roles aren’t enough, access logic gets scattered across hooks, services, and conditionals.

The Access Policy API gives developers a flexible alternative: a clean, centralized way to grant permissions based on real-world conditions — without overloading  or multiplying roles, or scattering access logic throughout a codebase.

In this session, you’ll learn:

• What changed in Drupal core with the introduction of the Access Policy API
• The anatomy of an access policy — how policies are structured, how they work, and how to write your own
• How to decide when to use roles, policies, or both
• How access policies can save time for site administrators by reducing role clutter and simplifying permission management
• What documentation and community resources exist for understanding the API 

If you’ve ever struggled to model complex access rules cleanly in Drupal, this talk will give you new tools — and a new way to think about permissions.

In today's rapidly evolving work environment, successful teams embrace diversity in all its forms, especially neurodiversity. Neurodivergent individuals—those with ADHD, autism, dyslexia, and other cognitive differences—bring unique perspectives, creativity, and problem-solving skills that can supercharge team performance.

This engaging talk will explore how neurodivergent team members enhance collaboration and innovation by leveraging their strengths. From heightened attention to detail to out-of-the-box thinking, neurodivergent minds offer invaluable assets that drive productivity and foster a culture of inclusion. Attendees will learn how to create environments that support all employees, encouraging each team member to contribute fully.

Drawing from personal experiences and research, we’ll dive into practical strategies for building neuro-inclusive teams and how embracing cognitive diversity can lead to better outcomes, greater empathy, and long-term success.

Three learning objectives

• The unique strengths neurodivergent individuals bring to teams—such as creativity, problem-solving, and attention to detail—and how these qualities can boost overall team performance.
• Practical strategies for fostering neuro-inclusive environments, including how to create spaces and workflows that accommodate different cognitive styles to ensure all team members can thrive.
• The importance of empathy and patience when collaborating with neurodivergent colleagues, and how understanding diverse perspectives leads to stronger communication and more effective teamwork.

I began my career as a developer, where building websites for clients and learning development best practices were my primary responsibilities. As I became a team leader and manager, I quickly learned that my job now had a very different set of objectives, priorities, and keys to success. Instead of solving technical problems with code, the most important parts of my days became addressing more ambiguous "people problems" and coaching my team members toward growth.

This session will cover how I shifted from a front-end development role into management, and the lessons I've learned that can help other developers thinking of making a similar move. I'll detail how delegation was my biggest struggle and greatest help, the importance of clear communication and expectations, and how to support my team while building their skills, not just my own. I'll also touch on the differences in feedback loops between development and management problem-solving, along with how to stay technical while spending less time directly working on code.

Curious about what AI can do in Drupal—but not sure where to start? This beginner-friendly session will introduce you to DrupalAI using a series of short, live demos powered by amazee.ai. You’ll see how to use the amazee Provider Framework and key AI modules to streamline content creation, enhance UX, and even automate tedious site tasks, all without writing a line of code.

We’ll break down what makes a good AI prompt for different Drupal use cases, show how to generate content and categorize it intelligently, and walk through launching your own ready-to-play-with DrupalAI site using amazee’s Advanced User Demo. We’ll also cover how makers, trainers, and maintainers can get unlimited AI credits to power their development efforts.

Bring your laptop if you want to follow along—we’ll get hands-on and leave plenty of room for questions, play, and ideas.

Matthew is a Drupal AI trainer who has open-sourced materials for other trainers. He is deeply involved with the Drupal AI Strategic Initiative. 

This session would walk through the practical steps of migrating existing Drupal projects or existing Drupal components to Drupal Canvas from a developer’s perspective. We’ll cover how to adapt or refactor Single Directory Components, reorganize component structures, props, slots, and how to avoid common pitfalls. The goal is to give you a clear understanding of how to prepare, migrate, and optimize your theme so it works properly with Drupal Canvas.

Nothing slows down a project—or a contribution—like pushing your code only to have GitLabCI reject it. Missed coding standards, preventable errors, and style issues waste review cycles and delay releases. Not anymore.

You’ll learn how to bring those same checks into your local environment so you can catch problems before they hit Drupal.org’s pipelines. By running the exact tools GitLabCI uses—ESLint, Stylelint, PHPCS, and PHPStan—you’ll cut down on frustrating back-and-forth, write more consistent code, and keep your contributions moving smoothly.

You don’t need deep expertise: I’ll provide ready-to-use configuration so you can get started right away.

I’ll cover:

• Installing and configuring each linter for Drupal
• Matching GitLabCI behavior locally
• Automating checks for faster feedback
• Catching issues early to speed up reviews and QA
• Extending checks beyond what GitLabCI enforces

Whether you’re submitting your first merge request or keeping client projects clean, these practices will improve your workflow, reduce wasted time, and help the whole Drupal ecosystem move faster.

At the end of this session, attendees will be able to:

1. Set up local code-quality tools (ESLint, Stylelint, PHPCS, PHPStan) in a Drupal project with provided configuration.
2. Run and automate the same checks used on Drupal.org’s GitLabCI to catch errors early and reduce failed builds.
3. Extend these checks to raise internal quality standards and deliver more consistent, maintainable Drupal code.

During the transition from Drupal 7 to 9 there was much hate for the front end experience of Drupal Development. What with Twig being new, the dependence on jQuery, and limitations to CSS, many believed that Decoupled was the new way to go.
Now we have a better understanding of Twig, Single Directory Components, and more options with native CSS. As well, now we have better caching and libraries. In this talk I will highlight these technologies which make the Frontend experience once again the way to go. 

Choosing the right content management system (CMS) can truly shape the success of your digital experience strategy. In this session, we’ll take a closer look at how Drupal stacks up against other well-known platforms like WordPress, Craft CMS, and Adobe Experience Manager (AEM) in terms of architecture, scalability, and customization. Here’s what we’ll cover: 

1. How each CMS approaches content modeling and flexibility
2. Key performance and scalability factors for large-scale projects
3. Insights on security, community support, and extensibility
4. When Drupal shines and when it might be wise to consider other options 

By the end of this session, attendees will walk away with a solid grasp of the strengths and weaknesses of each CMS, empowering them to make well-informed choices for their upcoming projects.

Drupal projects often begin with good intentions and end in a blur of template overrides, scattered business logic, and “kitchen-sink” modules where every new feature gets dumped because no one knows where else to put it. Themes swell with one-off tweaks, modules become grab-bags of unrelated responsibilities, and no one wants to touch anything for fear of breaking everything.

Modern Drupal can—and should—be engineered like a real software platform. Whether you're working on a single site, a multisite installation, or an internal Drupal-based product, the secret to stability--and sanity--is the same: think in packages.

In this session, we’ll explore a practical, accessible approach to package-driven Drupal development. You’ll learn how to transform messy, sprawling features into clean, isolated, versioned packages using modules, recipes, and theme components. We’ll walk step-by-step through encapsulation, API boundaries, directory patterns, and safe evolution—without overwhelming teams who are new to modern Drupal architecture. We’ll also look at the real organizational challenge most teams face: how to track, maintain, and evolve shared packages across multiple products, projects, and backlogs.

This session is designed for everyone—from themers and site builders beginning to understand components, to backend developers looking for better structure, to architects responsible for evolving large Drupal platforms. You’ll walk away with a new mental model, practical patterns you can apply immediately, and the confidence to start building Drupal features your future self—and your teammates—won’t hate.

Discover how AI can support content authors and editors. I will cover AI-powered content suggestions, automated tagging and summarization. See how AI can help teams work smarter while improving content quality.

Version control is a must-have in today’s web development landscape, yet many CMS developers find themselves grappling with Git workflows that are specifically designed for content-rich projects. In this session, we’ll dive into:

1. The basics of Git for CMS teams
2. Different branching strategies, including Git Flow and Trunk-Based Development
3. How to manage configuration and database changes in CMS settings
4. Helpful tips for integrating Git with CI/CD pipelines for platforms like Drupal and others 

Whether you’re just starting out with Git or you’re aiming to polish your existing workflow, this talk is here to help you enhance collaboration and ease those deployment challenges.

Git by yourself is easy: commit, push, done. But the moment a team joins the party, suddenly there are branches, pull requests, merge conflicts, and a complex workflow (that may or may not be documented). 

In this beginner-friendly session, we’ll demystify how teams actually use Git. You’ll learn common branching strategies, follow an example workflow from task to deployment, and walk away ready to collaborate with confidence.

Single Directory Components have changed the way some Drupal sites are themed. Drupal Canvas (formerly Experience Builder) has the potential to change how some Drupal sites are built. What happens when both are available widely?

In this session, we'll take a look at how to create forward-looking Single Directory Components that will integrate nicely with Drupal Canvas. We'll cover the basics of SDCs (especially their component.yml files) as well as demonstrate SDC usage inside of Drupal Canvas.

Drupal CMS launched  to much fanfare... to existing Drupal developers and customers.  Now, Drupal comes with AI agents, visual page builders, one-click Recipes. It's genuinely impressive tech. So why don't students or developers care?

Here's the uncomfortable part: we already fixed the technical problems. Drupal CMS isn't hard to use anymore. The learning curve is way better. We have actual innovation happening.

But new developers still aren't showing up. They're on YouTube, Discord, and Twitch learning JavaScript frameworks or the new hotness language.  The "Drupal is legacy tech" perception hasn't budged.

I'm a Drupal developer who streams game development on Twitch to an audience that mostly doesn't know what Drupal is. I've built unconventional projects like using Drupal as a game backend, and I spend time in gaming and indie dev communities where Drupal isn't even on the radar. I've learned what makes someone outside the Drupal bubble actually get curious about a technology. And what makes them scroll past.

This session is a frank conversation about the gap between having good tech and getting people to notice. We'll talk about:

• Where developers actually discover new frameworks (spoiler: not drupal.org)
• Why technical excellence doesn't equal excitement
• What we can do as individuals, not just "the community"
• Real examples of what's working vs. what we think should work

What you'll get: 3-5 concrete actions you can take this week, not someday. Plus a clearer picture of why the usual "let's market Drupal better" approach keeps missing the mark.

We have a very short window before Drupal CMS becomes "that cool thing that launched that nobody noticed." Let's actually do something about it.

What kinds of errors do you usually spot? A spelling mistake or off-brand product name? A slow page, an inaccessible feature, or a widget that’s awkward to use? Syntax errors or deprecated functions?

Everyone on a project notices quality issues—but not everyone feels equipped to fix them. Many teams already run checks such as code linting, copy editing, or accessibility reviews. But do these checks surface problems too late, competing with higher priorities? As preview environments and continuous integration become more common, you might realize you could use tools to catch errors sooner—but feel lost in a sea of jargon and complexity.

This session reframes QA as a shared responsibility that spans every role and stage of web development feature delivery. We’ll map the modern QA landscape and explore lightweight testing and preview tools anyone can use—from content editors to frontend and backend developers—to identify issues sooner and communicate them clearly.

Then we’ll see those ideas in action. The slides for this presentation will be hosted in a GitHub Pull Request and deployed through a Tugboat preview environment. Together, we’ll identify a late-detected error, propose a fix, commit it live, and watch the preview rebuild in real-time—demonstrating how an accessible, collaborative QA process can work.

Finally, we’ll examine how a local check could have identified the problem before the Pull Request was even opened, illustrating how you can continually learn from feedback and enhance your quality-assurance processes.

Attendees will leave with:

• A clear mental model of the QA landscape across roles
• Examples of small, approachable tools for checking quality locally or in CI/CD
• Practical ideas for building a QA process that both “shifts left” and shares responsibility

This hands-on workshop will teach participants how to leverage Drupal Views, one of the most powerful and flexible modules in Drupal, to create and manage dynamic content listings. We will demystify the Views user interface and demonstrate how to build various types of content displays without writing a single line of code. Participants will leave with the practical skills needed to create custom pages, blocks, and feeds to showcase their website's content in new and exciting ways.

Learn how to add AI capabilities to your Drupal sites, including chatbots, recommendation engines and sentiment analysis. This session includes real-world examples and step-by-step guidance for creating your own AI-enhanced modules.

Drupal is officially a DXP, but let's be honest: are we still fighting brittle, custom PHP code for every business rule? It's time to upgrade our workflow!

This session dives deep into the Event-Condition-Action (ECA) module and the Orchestration module—the definitive, goto solution for defining, visualizing, and executing complex business process automation entirely through an awesome visual UI. This means less debugging of custom hooks and more focus on delivering real business value.

We will explore high-value, real-world enterprise use cases, such as:

1. Dynamic Onboarding: Triggering external API calls (e.g., Salesforce, CRM) and sending custom email campaigns based on user registration and role assignment without a single custom hook_user_insert().
2. Advanced Content Moderation: Creating multi-step, conditional review flows that branch based on content type, taxonomy, or user metadata—no more wrestling with clunky default workflows.
3. Third-Party Integrations: Using ECA to act as a secure logic layer between Drupal and external services, expertly handling data flow, complex validation, and error states.

Attendees will walk away knowing exactly how to ditch the heavy, custom hooks and implement truly sophisticated business logic using a visible, maintainable orchestration layer. This isn't just theory—it's the strategy that drastically cuts technical debt and boosts your developer happiness.

Merlin of Chaos created Drupal Views back in 2003 and it remains a Drupal super-power to this day. Ironically, it creates order from chaos. It is the ultimate list maker and report generator with access to nearly everything that is contained in Drupal.  This is an introduction to Views that will benefit site builders, designers, content managers, and developers of all sorts. Learn to leverage the power of Views to make your Drupal site more useful. Content for this session was graciously contributed to by DrupalEasy. 

I started using AI over a year ago and kept hitting the same wall. Magic prompts, inconsistent results, starting over every time. Sound familiar?

Then I started building something different. Not better prompts. Frameworks.

Here's what I mean. After tailoring several resumes and repeatedly telling AI "don't embellish my experience" or "don't invent technologies I haven't used," I asked it to analyze our interactions and create a framework capturing all these recurring requirements. The framework became part of project knowledge, making future attempts consistent. No more repeating the same corrections.

When Claude released Skills, I recognized the concept. I'd been building something similar for over a year. Skills take it further with bundled code and executable scripts. My frameworks focus on workflow stages, MCP tool orchestration, and preserving human decision points. Same core idea, different implementations.

The results: 3 published Drupal contrib modules, 17+ blog articles, automated social media campaigns generating 5-10 posts per piece. For Drupal development, I have AI read SDC documentation, Core code, and relevant resources, then create frameworks from that foundation.

You'll see the actual frameworks I use. Phase-based development for contrib-quality modules. A 7-stage editorial workflow with real quality control. Content systems with database tracking. I'll show what failed along the way and demonstrate how frameworks turn AI from unpredictable helper into reliable partner.

Whether you're developing modules, writing content, or analyzing data, these systems work because they're built on what you already know, not AI magic.

Agile can feel like a set of mysterious spells everyone else already knows. In this fun, beginner-friendly session, we’ll break down Agile from a developer’s point of view: what the terminology really means, what actually happens during sprints, and how to talk about Agile confidently in interviews and on the job. 

Whether you’re new to development or just new to Agile, you’ll be casting spells in no time (wand optional).

Performance is key for any Drupal site. This session will cover caching, database optimization, image handling and other practical strategies to make your site faster and more reliable.

Learn how volunteers from the Drupal community built a platform that provides instant demos of Drupal site templates and how you can use Drupal Forge to market amazing Drupal services.

How do you learn how CI/CD pipelines work when your workplace systems feel too complex or risky to experiment with? When I pivoted from creating Drupal tutorials into the DevOps and QA space, I needed a safe, low-stakes environment to understand how automated workflows really function. So I built a small personal playground: a Hugo-powered blog, stored in a GitHub repository and published through GitHub Pages. From there, I began adding the QA tools I was used to using at work to see how they could run automatically in my personal deployment pipeline. That hands-on exploration helped me understand more complex DevOps workflows and gave me ownership of quality checks for my own site.

In this session, we’ll place CI/CD pipelines within the broader QA landscape. I’ll share an overview of the types of quality checks people rely on, including content linting, accessibility checks, link validation, code style tools, and how different roles use them to check their own work and review others’ code. Then we’ll walk through how to transition from an in-editor check to a local command-line tool, to an automated step inside a CI/CD workflow.

I’ll show you how I built my first CI/CD pipeline and how I iteratively added simple QA checks that now run automatically on every commit. We’ll examine the GitHub Action that powers my pipeline, and I’ll also share small, parallel examples of how the same workflow would appear in GitLab CI/CD and Bitbucket Pipelines.

Attendees will leave with:

• A clear, beginner-friendly mental model of CI/CD
• Practical QA tools that they can run manually, locally, or in automation
• A personal deployment workflow that they can recreate immediately
• Confidence to continue exploring DevOps through small, safe, meaningful steps

AI adoption has surpassed any previous technology, and is quickly becoming the primary way people research buying decisions. In fact, AI agents can now even make purchases, so customers can even buy from you without even visiting your website.

There's lots of exciting progress on how Drupal can integrate AI for content generation, chatbots, and even site building and even more complex tasks. Most sites have already experienced the impact of mass ingestion of content by AI crawlers, and there's an evolving set of approaches to mitigate those effects.

The bigger question, however, is: how does AI change what a website need to be? In this session we'll explore the ways a Drupal website can be built to best suit the needs of a web where Large Language Models (LLMs) and similar tools are the primary interface people use to start their online journeys.

Accessibility issues don’t have to surprise you — or your users. Continuous AI for Accessibility is an approach to building accessible products by embedding tools, AI, and best practices directly into the development process. In this session, we’ll share how we built our open-source prototype and show features like automated accessibility scans and alerts with GitHub Actions, AI-driven fixes from Copilot, and collaborative pull requests that keep humans in the loop. The result: developers tackle issues seamlessly, accessibility best practices become second nature, and teams are ready to build inclusive products from day one.

Hat tip to Talking Drupal for clueing me in to the Custom Field module right at the time I was exploring rolling my own custom entities to solve a longstanding client issue: feeds imports containing paragraph fields.

The problem: 

Updating a 4000ish node data set with a few dozen fields—only four of which were paragraphs—via xml feeds import would take around 27 hours to complete. Deleting and reimporting from scratch "only" took about an hour, with the obvious disruptions and caveats.

Enter Custom Field:

Building a site template and not sure where to begin? In this session, we’ll share lessons learned from developing our own recipe-based site templates. You’ll hear what worked, what didn’t, and how you can avoid common pitfalls.

We’ll explore the Drupal Recipes ecosystem, starting with basic usage and moving into advanced strategies for creating scalable, reusable recipes that can be assembled to meet the needs of different site templates. 

You’ll learn how to:

• Get a high-level overview of using recipes to build site templates
• Organize recipes so they remain flexible and extendable
• Empower site administrators to pick and choose the recipes that fit their needs
• Use tools to automate and test recipe building for scalable, reliable site template delivery
• Handle dependencies cleanly to avoid brittle stacks
• Apply real-world examples to your own projects

Through real-world examples and a live demo of our recipe stack, you’ll leave with practical knowledge and the confidence to structure recipes that meet your organization’s needs today while remaining adaptable for the future.

AI is now part of everyday development and is here to stay. This session will demonstrate how to utilize Claude Code, Claude Desktop, and ChatGPT as practical co-pilots for real-world Drupal work, with a focus on Drupal MCP, the Tool API module, and the Audit Export module.

We will start with easy, low-friction workflows you can use right away. You will see how to use LLMs to debug custom modules, refactor legacy code, reason about configuration, and write tests against your existing Drupal projects. Along the way, we will compare Claude and ChatGPT at a high level, discuss their strengths and trade-offs, and explain why many developers currently lean toward Claude for in-depth coding and Drupal development while still using ChatGPT for quick ideas, documentation, and non-code help.

We will also look at how to choose between Claude Code and Claude Desktop. Both can handle multi-file workflows, so we will focus on context length and task size. You will see when larger, more complex coding tasks are a better fit for Claude Code, and when smaller, targeted changes and focused prompts work better in Claude Desktop.

From there, we will step inside Drupal itself. You will learn about the Tool API module, how tools are defined in Drupal, and how Drupal MCP enables AI clients to call those tools in a safe and structured way. Using the Audit Export module as a concrete example, we will demonstrate how it can expose structured data about your site, enabling AI to perform configuration audits, highlight potential issues, and suggest next steps for your Drupal installations.

You will leave with a clear picture of:

• When to reach for Claude vs ChatGPT in a Drupal context
• How to decide between Claude Code and Claude Desktop for different tasks
• How Tool API and Drupal MCP work together to let AI "talk" to Drupal
• How Audit Export can power AI-driven audits of your Drupal sites

No prior AI experience is required, only basic familiarity with Drupal development.

Just like Atreyu’s epic quest, the journey toward digital accessibility is never truly over. Standards evolve, technologies shift, and new contributors appear out of the Nothing to add features and documentation that might undo your careful compliance. Even if your code and design follow today’s guidelines, tomorrow’s update can send you straight back into the Swamps of Sadness.

In this session, we’ll explore how to keep accessibility alive throughout the lifecycle of your open source projects, from the first line of code to ongoing maintenance. You’ll learn how to chase the next accessibility dragon without losing the magic you started with. We’ll even consult the Oracles of WCAG and peek into the mysterious new lands shaped by the European Accessibility Act to see what’s coming next for inclusive design.

Attendees will leave this adventure with:

• Ways to improve accessibility on existing projects without getting lost in the clouds over Fantasia
• Strategies for getting stakeholder and team buy-in to keep accessibility a long-term priority
• Tips on testing across browsers, devices, and assistive technologies (your modern-day luck dragons)
• A treasure map of free tools to keep your sites compliant before and after deployment
• A glimpse of what’s on the horizon for WCAG and the EAA, because this story, like accessibility, truly never ends

Have you used CiviCRM and wished it were truly native to Drupal? Or struggled to integrate an external CRM with your favorite CMS?

Join us to explore Drupal CRM, a modern Drupal-first contact relationship management system.

Created to match the site building spirit of Drupal CMS, it’s designed to serve organizations of all sizes, with a special emphasis on those with limited technical or financial resources.
Just as Drupal CMS reimagines content management, Drupal CRM empowers site builders with structured contact data, right inside Drupal.

Avoid costly and complex integration with a proprietary CRM by consolidating data and business logic in a single powerful Drupal-based platform!
 

Drupal sites rarely stay simple for long. New content types, fields, roles, and menus are added over the years, often by different teams. When it is time for a redesign, a migration, or a new feature, one of the most complex parts is answering basic questions like “what is actually on this site,” “what is still in use,” and “where is this configured.”

This session will examine common discovery challenges and demonstrate how the Audit Export module can provide a clear, repeatable view of a Drupal site. We will focus on how Audit Export helps you prepare for redesigns and migrations, understand inherited projects, and keep ongoing work grounded in the actual structure of the site.

You will see how to run the built-in reports from the admin UI to review content types, fields, roles, menus, taxonomy vocabularies, and views. From there, we will examine scheduling those audits to run regularly, exporting results to CSV for your team, and utilizing Drush commands to integrate audits into technical discovery, deployment, and maintenance workflows. Along the way, we will briefly note that Audit Export is also available as a plugin for WordPress, allowing the same approach to be used across mixed Drupal and WordPress portfolios.

To conclude, we will explore how the Audit Export Tool submodule exposes audits through Drupal’s Tool API, enabling other systems to interact with them in a structured manner. This opens the door to automation and deeper analysis, including integration with modern tools like ChatGPT and Claude when you are ready to explore AI-assisted workflows.

You will leave with a clear understanding of:

• How to use the default Audit Export reports to understand site structure quickly
• How to add custom reports for site-specific entities and business rules
• How to schedule and automate audits with cron and Drush
• How the Audit Export Tool submodule and Tool API prepare your site for integration with external tools

No prior experience with automation or AI tools is required. Basic familiarity with Drupal administration or development is recommended.

This session provides a comprehensive overview of Drupal's caching layers. We will start with the fundamentals of cacheable metadata, including cache tags, contexts, and max-age, which are the building blocks of the Cache API. Then, we'll dive into the render pipeline and fragment caching, exploring how Drupal caches parts of the render tree.

Next, the session will cover response caching, contrasting Dynamic Page Cache and Page Cache. We'll also discuss how to leverage reverse proxies and CDNs for even greater performance.

Finally, we'll equip you with practical skills for debugging the cache and writing cache-aware code, including creating custom cache contexts and avoiding common pitfalls like unintentionally uncacheable blocks.

This session is for Drupal developers and site builders that to build reliable and performant websites that update automatically without requiring constant cache rebuilds.

Drupal CMS is a great starting point! It gives us a lot of flexibility right out of the box, but you still need to understand how Drupal works and the philosophy behind Drupal CMS.

In this session we'll cover all of the tips and tricks you need to know about building sites specifically with Drupal CMS, including enabling modules, designing with Drupal Canvas (at whatever usability level we have at the time of the Camp), turning on Drupal AI and other cool tools.

This session is for people looking at Drupal CMS as an option.  It is not a deep-dive into the code.