Agenda

Registration will start at 8am. We'll have a full continental breakfast including coffee, pastries, and fruit. 

Start the day with FLDC updates, thank yous, and announcements!

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.

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.

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. 

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.

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.

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. 

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.

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:

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.

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!
 

Lunch from world famous Gringos Locos! This is basically an awesome burrito bar, where you can also find vegetarian, vegan, and gluten free meal options. This lunch is included with your ticket!

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

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.

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.

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.

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.

Components break when the content model underneath is rigid. This featured session reveals how content strategy decisions made months before Drupal implementation—field structure, required versus optional, granularity, relationships—directly determine whether your component system enables speed or becomes a bottleneck.

Drawing on platforms serving 50+ Iowa state agencies, 80+ Georgia government websites, and Georgia Public Broadcasting's multi-brand system, you'll see the complete content modeling process: from workshops with authors using paper prototypes, through data dictionary work (cardinality, character limits, display variations), to embedding simplified specs into Figma files so designers can stress-test with real content constraints. You'll discover common pitfalls that hurt component flexibility and learn field structures that enable the same components to serve wildly different organizational needs—without custom code for every use case.

The session concludes with an audience-driven demo: suggest an agency and page type, and we'll build it together in real time—proving the model's flexibility on the spot.

This session is for content strategists, developers, site builders, and UX designers working with component-based systems at scale; anyone tired of hearing "but we're different" from their stakeholders is welcome.

You'll leave knowing:
 - Where to put guardrails versus where to allow flexibility
 - How to validate content models before AND during building
 - Field-level decisions that make or break component reusability

Structure doesn't restrict flexibility—it enables flexibility at scale. But you need to know where the guardrails belong, because components are only as flexible as the content model underneath them.
 

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.

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.

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

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.

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.

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.

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.

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!

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.

Lightning Talks are short (5min-ish) impromptu sessions on anything you want. Do you have something you’re proud of? Do you have a new technique that’s saving you time? Have you learned about something cool? Get up and share!