What the Canvas announcements mean for Layout Builder

I watched the Canvas announcement come through at DrupalCon Barcelona in September. The project has been developing in the open, but seeing it positioned as a core initiative — the next big bet for Drupal’s content composition story — felt like an acknowledgement of something the community has known for a while: Layout Builder is good at what it does, but what it does is not the whole problem.

That sounds like criticism, and it is not. Layout Builder was built to solve a specific problem: let non-developers assemble pages from components without touching code. For that use case, it is solid. But solid is not the same as the thing everyone needs. And over the last three years, I have watched enough implementations stumble when they tried to stretch Layout Builder into something it was not designed to be that I think Canvas is less about replacing Layout Builder and more about asking a harder question: what does composable content need to actually look like in Drupal?

What Layout Builder got right, and what it assumes

Layout Builder’s core insight is good: if a component is reliable and reusable, the markup is not the issue. The issue is making it easy for an editor to pick the right component and fill in the data. Layout Builder does that. An editor sees a list of blocks, clicks one, configures some settings, and the block appears in the layout.

This works because it assumes a thing that is often true: the components are stable. A card component has a title, a description, and an image. The card looks the same everywhere. Layout Builder orchestrates editors and cards.

The assumption fractures when the component itself changes context. The card on the homepage needs different styling than the card in the sidebar. The component’s settings change depending on where it appears. Layout Builder has configuration tools for this, but the tools grow complicated quickly. You end up with a component that is flexible enough to work everywhere and therefore specialized for nowhere.

What Canvas seems to be asking

The Canvas work I have seen so far is asking a different question: what if we stopped trying to make one component work everywhere and started making composition itself more expressive?

Instead of “configure this card for the homepage,” you might have “compose a featured-article block that contains a card and a call-to-action, styled for the homepage.” The card stays simple. The composition layer handles variation.

This is not revolutionary — it is how component design has worked in isolated frontend systems for years. But in Drupal, where the separation between component and composition has always been blurrier, it is a real shift.

Why this matters for implementations

I have watched exactly one multisite platform I was not directly involved with successfully run Layout Builder at scale. Most hit a wall where either editors need more control (and end up wanting a WYSIWYG), or the components need more variation (and end up with dozens of configurations that break coherence), or both.

Canvas acknowledges that the wall is real. It is also saying: we think the solution is not to make Layout Builder more powerful. It is to make composition itself a first-class concern.

The practical difference: in Layout Builder, editors pick blocks and configure them. In Canvas, I think editors will be able to compose interactions — to say “this card triggers a modal” or “this image is interactive.” The blocks stay simple; the composition layer handles complexity.

For a university platform where different schools need genuinely different interaction patterns, that is foundational. It means a component library can stay coherent while supporting real variation in how those components work together.

What I am watching

The risk is that Canvas becomes another layer of abstraction without solving the core problem: people want different things, and making variation easy does not make it free. A system where editors can compose anything is a system where no two pages look the same unless someone writes strong governance. Strong governance is what limits an editor’s agency, which is why they wanted a visual builder in the first place.

The strongest version of Canvas would need to say: “Composition can happen here, in these ways, using these patterns.” The weakest version would be: “Composition can happen anywhere in any way.” The strongest version would look like governance. The weakest would look like a WYSIWYG with extra steps.

I think the Drupal community is capable of the strong version. I am watching to see whether the Canvas work lands that way.

Until I see the first full Canvas implementation at scale, I am cautiously interested rather than convinced. Layout Builder solved the problem it was built for. Canvas is asking a bigger question: what if we rethought composition entirely? The answer matters. The execution matters more.