Our keynote speaker will be Joyce Peralta, an acclaimed digital communications leader focused on content strategy, governance, and scalable editorial operations. As Manager, Digital Communications, at McGill University, she partners with cross‑functional teams to shape accessible, sustainable content ecosystems. Joyce's work focuses on aligning communications, user experience, and digital infrastructure to optimize content workflows and deliver cohesive experiences across complex ecosystems.

An award‑winning speaker, Joyce has presented at international conferences including DrupalCon, CMS Connect, ConFoo, ContentEd, Digital Collegium, and EvolveDigital.

Digital transformation isn’t just about adopting new tools and establishing new policies, it’s about reshaping the foundations that allow our systems, content, and teams to evolve. As organizations modernize their architectures, shift to systems that support greater adaptability and reuse, and experiment with AI, it becomes increasingly clear that successful transformation depends on the strength and alignment of our digital foundations.

This keynote explores how transformation takes root, not just through new tools and policies, but through shared understanding, intentional structures, and the collective effort of people committed to a common goal. Drawing from real-world experience modernizing a complex digital ecosystem, Joyce Peralta shares insights that will resonate with developers, designers, content strategists, and product leaders alike.

We’ll explore:

• How collaboration and clarity facilitate transformation.

• How shared language, purposeful governance, and strong communities of practice create alignment that accelerates change.

• Foundational groundwork to prepare for an AI-driven future, including structured content models, unified design and UX patterns, and processes that ensure reliable, reusable, machine-understandable content across platforms.

Attendees will gain practical insights into transforming their digital ecosystems in ways that support modern architectures, accelerate collaboration, and prepare their organizations for the opportunities and demands of AI-powered experiences.

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.

Complex decoupled projects can span 5-8 technical partners: CMS, hosting, DAM, commerce, search, personalization, trust. The ownership of how those experiences come together belongs to the agency project team. It's an essential practice that's easy to lose beneath the more urgent, more visible work of getting each partner's platform integrated. This session offers a governance framework, Ownership, Visibility, Verification, for supporting that ownership across the project lifecycle, keeping partner handoffs accountable and accessible for all users, including those relying on assistive technologies, with particular attention to the AI harnesses and agents now operating at nearly every seam.

Join us as we walk through real decoupled builds across Contentful, Drupal, and Contentstack - and how each project's architecture choices unlocked AI-ready, activation-centered experiences that gave them the edge they needed.

Most digital platforms weren't built for the world they now serve - AI-driven discovery, omnichannel content reuse, and personalization at scale. Legacy architectures can lock teams into rigid templates and costly replatforming cycles.

JAKALA takes a maturity-first approach: meet each client where they are, decouple where it matters, and design structured content models that flex across surfaces without starting over.

We'll survey seven different projects across three different platforms and five different industries and learn what each have in common and how they differ

This session introduces web developers to the world of IoT through ESPHome, a tool that lets you configure and flash microcontrollers using nothing more than a YAML file and a web browser.

We'll walk through building a functioning IoT device using an ESP32. Wire it up, write configuration, flash it, and control it via its built-in REST API. No prior hardware experience or embedded systems knowledge is required. All you need is comfort with APIs and config files.

By the end of the session attendees will understand how ESPHome works, how to think about IoT devices as headless services, and will have a clear path to building their own devices at home.

Context is the real secret sauce for AI. And if your application is 100% driven by customizable configuration, then you've got all the secret sauce you need, because your config info expresses the complete context for what your application is and how it works.

Let me walk you through the creation of a 100% configuration-driven application in Formulize, a free and open source platform for making data management systems. We'll use the built in MCP server in Formulize to create the application, and we'll look at how end users can immediately use AI in the same way, to do any day-to-day tasks, from data entry, to data validation, to ad hoc reporting. No vibe-coding, no security or maintenance issues, just structured tool use via MCP, that does not hallucinate because it has your entire configuration as context.

AI is increasingly being integrated into modern, decoupled architectures, but most implementations still rely on short-lived, request-based interactions. While effective for many use cases, this approach can fall short when workflows require continuity, coordination, and ongoing decision-making.

This session introduces the concept of persistent AI agents as an emerging pattern for addressing these gaps.

Using examples built with amazeeclaw, we will explore how long-running agents can retain context, monitor systems, and interact with APIs and services over time. These agents operate alongside existing components in a decoupled architecture, enabling new approaches to workflow orchestration and system interaction.

The session will include practical demonstrations of agents performing tasks such as observing changes, applying rules, and coordinating actions across systems. Each example will be used to illustrate architectural considerations, including state management, system boundaries, and integration patterns.

Non-profits are sitting on a content problem that is quietly getting worse. Their teams are already stretched thin, every piece of content touches multiple stakeholders before it goes live, and the traditional solution (hire more people, add more process) is simply not available to them.

This session is about what becomes possible when you treat the content supply chain as something that can be engineered, not just managed. Agentic workflows and automation are not just productivity tools for large enterprise teams. They are, arguably, the most practical upgrade available to resource-constrained, mission-driven organizations that need to move content from idea to published faster, with fewer people, and with less friction at every stage.

This talk explores the overlooked experiences of neurodivergent developers (for example, those with autism, ADHD, or similar traits) and how these qualities shape our professional lives. Drawing on my own journey and insights, this session seeks to break the taboo around discussing neurodiversity in tech.

I’ll share how masking, sensory sensitivities, and autistic burnout have influenced my life and career, and why I chose self-employment to better manage noisy offices and endless meetings. Recognizing my neurodivergence as an adult was eye-opening, and I’ll touch on the deeply personal decision around getting a formal diagnosis. My goal isn’t to diagnose anyone or speak for others, but to offer a personal perspective on how accepting these traits can positively affect work, self-acceptance, and day-to-day life.

Composable promised flexibility and best-in-class providers. Too often it delivers integration spaghetti, brittle releases, and a developer experience that loses to the monoliths it was meant to replace. That gap is the composable tax.

Next-Hydra (next-hydra.dev) is an open-source, MIT-licensed TypeScript monorepo template, built at Jakala, that exists to close that gap. It composes Contentstack, Commercetools, WorkOS, and a production-grade ops layer into a single Next.js codebase one full-stack team can ship from on day one.

The headless CMS landscape is crowded — Contentful, Sanity, Hygraph, Strapi — but when it comes to building AI-powered digital experiences, not all content platforms are created equal. This session makes the case that Drupal is the strongest choice for teams who want a headless CMS that's ready for the age of AI.

We'll start by examining what AI actually needs from a content platform: structured, well-modeled data; robust APIs; flexible workflows; search capabilities; and an extensible architecture that can integrate with fast-moving AI tooling. Drupal delivers on all of these out of the box — with powerful content modeling, native JSON:API and GraphQL support, and a mature ecosystem for e-commerce and search.

But the real story is what's happening right now with the Drupal AI initiative. From AI-assisted content generation and intelligent search to the Drupal Canvas page builder and a native MCP server, Drupal is building an extensible AI framework that purpose-built SaaS headless CMSs simply can't match — especially for complex, enterprise-grade use cases.

Come enjoy light hors d’oeuvres (vegetarian, vegan, and gluten-free options will be available) and beverages for this beloved annual tradition that’s happened every year since our first edition in 2017. Network with fellow attendees, mingle with speakers and sponsors, and extend the hallway track. Please note that your attendee badge will be required for admission (no outside guests) and the Decoupled Days Code of Conduct remains in full effect for our official conference party.

Siboire Saint-Laurent

5101 Boul. Saint-Laurent

Montréal, QC

H2T 1E4

Modern composable architectures give teams a structural advantage for discovery - but only if they rethink how discovery works. As GEO shifts the strategic unit from the web page alone to the content model, the quality of entity relationships, metadata, governance, and the system's ability to expose reliable information across channels and answer environments, the old SEO playbook is no longer sufficient.

This session draws from the "SEO to GEO: Mental Models" series (SALT.WORK) to make the case that discoverability is now a systems problem - and that composable platforms are uniquely positioned to solve it.

Drupal Canvas and Code Components are creating new possibilities for modern Drupal front-end development. However, many organizations already maintain established JCC (JavaScript Code Component) libraries and design systems outside of Drupal.

This session explores how Drupal Canvas Workbench can be used to integrate existing JCC component libraries into Drupal workflows without rebuilding components from scratch.

AI-assisted development is accelerating delivery—but in decoupled architectures, it’s also reshaping how quality breaks.

Pull requests are larger, more complex, and often generated or heavily assisted by AI. They move fast—sometimes faster than they can be meaningfully reviewed. QA teams are left validating systems they didn’t fully see being built, while the source of truth for requirements becomes blurred across tickets, prompts, and generated code.

In many cases, the implementation is the specification.

This raises uncomfortable questions:

• What does “good coverage” mean when code is generated faster than tests?

• How do you review or validate logic you didn’t explicitly design?

• Where is the source of truth when requirements are implicit or evolving in prompts?

• Can traditional QA even keep up without becoming a bottleneck?

This session doesn’t present a single solution. Instead, it explores emerging patterns teams are experimenting with—TDD, shift-left practices, AI-assisted testing, stronger contracts, and automation-first approaches—and where they succeed or fall short in real-world decoupled systems.

The goal is to reframe how we think about quality in high-velocity, AI-influenced development—and to better understand which problems we’re actually trying to solve.

With Drupal's introduction of Single Directory Components and the ability to have CSS bound to a component, it is not as necessary to have your design system “built”. One can use native CSS (and JS) in each component and not need to compile into a single stylesheet. Additionally, the ecosystems of Webpack, Vite, and whatever 12 other systems have popped up since you started reading this paragraph, are constantly changing or deprecating. In this talk we will go over the killer features of Sass and how you can use native CSS to replace them. Also may go over moving off of an old design system into Single Directory Components. If time permits we can go over PostCSS and the how it assists.

AI-generated content is quickly becoming mainstream, but what does that mean for CMS architecture?

Today, most headless CMSs store structured content that is detached from presentation. Editors and AI operate on abstract fields without real awareness of layout, components, or design constraints. The result? AI features feel bolted on: generating text for individual fields rather than producing coherent, design-aware pages.

Up to 40% of code is now AI-generated, but developers trust AI output less than ever. The problem isn't the tools, it's that we're using them wrong. We treat development as uniform when AI tools excel at fundamentally different work: CLI agents like Claude Code are exceptional at broad scaffolding, while IDE tools like Copilot dominate precise refinement. I'll present a phased development model drawn from building architecture and film production that separates generative work from refinement work, aligns the right tools to each phase, and introduces the "scaffold" as a new artifact type between specification and finished software.

Headless CMS platforms promise flexibility, speed, and omnichannel delivery. In enterprise environments, though, the hardest part of a replatform is rarely the technology. It is getting people with competing priorities to agree on what the content model should do, and why.

In this session, Anna Kucera shares lessons from guiding a major hospital system through a replatform from a legacy CMS to Contentful. What looked like a technical migration quickly exposed deeper organizational challenges: more than a dozen stakeholder groups, inconsistent legacy content structures, decentralized ownership, compliance requirements, editorial needs, SEO considerations, and pressure to retire multiple systems at once.

AI coding agents can write features, open PRs, and pass test suites. But without the right infrastructure around them, they'll also cross architectural boundaries no one wrote down, consult documentation that's out of date, and ship UIs that don't look quite right - all while reporting green builds. The problem isn't the agents. It's that most codebases rely on tribal knowledge and human judgment for things that need to be explicit and machine-checkable.

This session walks through the practical infrastructure built for a multi-workspace monorepo.

We'll cover four layers of formalization, each with concrete examples:

Executable architecture checks. How we used dependency-cruiser and custom structural analysis scripts to enforce cross-workspace import boundaries and ownership rules in CI.

Documentation as a hierarchy. Why a monolithic instructions file doesn't work for agents, and how restructuring into a scoped hierarchy with clear delegation made agents load only the context relevant to their current task.

Explicit cross-workspace contract ownership. How assigning owners and consumers to shared contracts made cross-workspace ripple effects visible at PR time instead of as bugs in production.

Visual verification for agent workflows. How we added Playwright screenshots and screen recordings to agent-generated PRs so that there's visual evidence of what the agent built - not just passing tests. This is what moves agent output from "probably fine" to "I can see that it works."

Throughout the session, we'll connect each layer back to a core insight: the same properties that make a codebase easier for humans to maintain make it dramatically easier for AI agents to contribute correctly. If you're already writing code with AI assistance, this talk will give you a concrete playbook for making that collaboration more reliable.

In the early days of headless, we sacrificed the editorial experience for frontend performance. By 2026, that compromise is officially obsolete. Drupal CMS 2.0 has arrived not just as a content repository, but as a sophisticated orchestration engine that bridges the gap between structured data, AI-driven generation, and high-performance frontends like Next.js and Astro.

At the heart of this revolution is Drupal Canvas. This session dives into how Canvas provides a "True-to-Life" real-time preview of headless frontends, while simultaneously serving as an AI-native workspace. We will explore the Context Control Center—Drupal’s new "Brand Brain"—which ensures that every AI interaction, from content drafting to component generation, remains grounded in your organization's specific brand voice and design system.

Nonprofits don't need new platforms. They need the ones they already have to work together and to think.

This session walks through how Anyone Can Fundraise connects existing nonprofit tools (CRMs like HubSpot and Salesforce, Google Workspace, email platforms, donor databases) with AI through MCP (Model Context Protocol) servers, Claude, ChatGPT, Microsoft Copilot Studio, and modular skill architectures. No rip-and-replace. No six-month implementation. Just wiring intelligence into the systems organizations already use and trust.

Decoupled Days is the conference where I feel safe skipping the part of my intro where I argue that building web UI with a JavaScript framework is a good idea.

We started building Code Components in Drupal Canvas on that premise. The goal was to let developers bring React components into Drupal and make them work inside Canvas's drag-and-drop experience, reaching feature parity with Drupal's Twig-based Single-Directory Components.

This journey began with a built-in code editor, followed by a CLI tool to sync components to and from a local codebase. Then AI coding agents happened, and the local codebase became increasingly important. So we made sure any React project can sync components, and we developed rich agentic tooling.

The next evolution: first-class support for decoupled frontend apps that fully take over preview rendering in Canvas. Join this session for an early look at Canvas Headless — its public debut. No deep Drupal or Canvas experience needed; I'll cover the necessary context along the way. You'll leave understanding how React components live inside Canvas today — and how to bring in any framework as a fully decoupled app.

Artificial intelligence is no longer a future initiative, it’s already embedded across today’s organizations. Developers are using coding assistants, marketers rely on generative AI for content, customer support teams leverage AI-powered tools, and business users connect new AI services every day. Most of this adoption happens organically, outside traditional IT planning, creating what I call the Invisible AI Department.

This session explores why AI governance is fundamentally an engineering challenge rather than simply a compliance exercise. We’ll examine how modern AI systems introduce new architectural concerns, including model selection, prompt security, retrieval-augmented generation (RAG), MCP servers, identity, observability, auditability, and private deployments.

Through real-world architectural patterns, attendees will learn how to build AI-enabled applications that remain secure, scalable, and maintainable without slowing innovation. The session focuses on practical implementation strategies that developers, architects, and technical leaders can immediately apply within their own organizations.

Topics Covered

* How Shadow AI became the Invisible AI Department

* Why AI governance starts with architecture, not policy

* Secure AI application design patterns

* Governing LLMs, MCP servers, and AI agents

* RAG security and enterprise data boundaries

* AI observability, auditing, and lifecycle management

* Practical guardrails for enterprise AI adoption

Who Should Attend

Software engineers, solution architects, technical leads, engineering managers, platform engineers, and anyone building or integrating AI into modern applications.

What Attendees Will Learn

By the end of this session attendees will understand:

* Why every organization already has an Invisible AI Department.

* The architectural risks introduced by unmanaged AI adoption.

* How to design AI systems with governance built into the architecture.

* Practical patterns for deploying AI responsibly without sacrificing developer productivity.