This blog has been re-posted and edited with permission from Dries Buytaert’s blog.
Decoupled Drupal has seen adoption from all corners of the Drupal community. In response to the trend towards decoupled architectures, I wrote blog posts in 2016 and 2018 for architects and developers about how and when to decouple Drupal. In the time since my last post, the surrounding landscape has evolved, Drupal’s web services have only gotten better, and new paradigms such as static site generators and the JAMstack are emerging.
Time to update my recommendations for 2019! As we did a year ago, let’s start with the 2019 version of the flowchart in full. (At the end of this post, there is also an accessible version of this flowchart described in words.)
Different ways to decouple Drupal
I want to revisit some of the established ways to decouple Drupal as well as discuss new paradigms that are seeing growing adoption. As I’ve written previously, the three most common approaches to Drupal architecture from a decoupled standpoint are traditional (or coupled), progressively decoupled, and fully decoupled. The different flavors of decoupling Drupal exist due to varying preferences and requirements.
In traditional Drupal, all of Drupal’s usual responsibilities stay intact, as Drupal is a monolithic system and therefore maintains complete control over the presentation and data layers. Traditional Drupal remains an excellent choice for editors who need full control over the visual elements on the page, with access to features such as in-place editing and layout management. This is Drupal as we have known it all along. Because the benefits are real, this is still how most new content management projects are built.
What do you intend to build?
The essential question, as always, is what you’re trying to build. Here is updated advice for architects exploring decoupled Drupal in 2019:
- If your intention is to build a single standalone website or web application, choosing decoupled Drupal may or may not be the right choice, depending on the features your developers and editors see as must-haves.
- If your intention is to build multiple non-web experiences (native mobile or IoT applications), you can leverage decoupled Drupal to expose web service APIs and consume that Drupal site as a content repository without its own public-facing front end.
What makes Drupal so powerful is that it supports all of these use cases. Drupal makes it simple to build decoupled Drupal thanks to widely recognized standards such as JSON:API, GraphQL, OpenAPI, and CouchDB. In the end, it is your technical requirements that will decide whether decoupled Drupal should be your next architecture.
Are there things you can’t live without?
As I wrote last year, the most important aspect of any decision when it comes to decoupling Drupal is the list of features your project requires; the needs of editors and developers have to be carefully considered. It is a critical step in your evaluation process to weigh the different advantages and disadvantages. Every project should embark on a clear-eyed assessment of its organization-wide needs.
Many editorial and marketing teams select a particular CMS because of its layout capabilities and rich editing functionality. Drupal, for example, gives editors the ability to build layouts in the browser and drop-and-drag components into it, all without needing a developer to do it for them. Although it is possible to rebuild many of the features available in a CMS on a consumer application, this can be a time-consuming and expensive process.
This balancing act between the requirements that developers prioritize and those that editors prioritize will guide you to the correct approach for your needs. If you are part of an organization that is mostly editorial, decoupled Drupal could be problematic, because it reduces the amount of control editors have over the presentation of their content. By the same token, if you are part of an organization with more developer resources, fully decoupled Drupal could potentially accelerate progress, with the warning that many mission-critical editorial features disappear.
Current and future trends to consider
I predict that static site generators will gain momentum in the coming year due to the positive developer experience they provide. Static site generators are also attracting a middle ground of both more experienced and less experienced developers.
With the introduction of fully decoupled static sites as an another architectural paradigm that developers can select, there is an even wider variety of architectural possibilities than before. It means that the spectrum of decoupled Drupal approaches I defined last year has become even more extensive. This flexibility continues to define Drupal as an excellent CMS for both traditional and decoupled approaches, with features that go well beyond Drupal’s competitors, including WordPress, Sitecore and Adobe. Regardless of the makeup of your team or the needs of your organization, Drupal has a solution for you.
Accessible version of flowchart
This is an accessible and described version of the flowchart images earlier in this blog post. First, let us list the available architectural choices:
- Fully decoupled static site. Use Drupal as a data source for a static site generator and, if needed, deploy to a JAMstack hosting platform.
Second, ask the question “What do you intend to build?” and choose among the answers “One experience” or “Multiple experiences”.
If you are building one experience, ask the question “Is it a website or web application?” and choose among the answers “Yes, a single website or web application” or “No, Drupal as a repository for non-web applications only”.
If you are building multiple experiences instead, ask the question “Is it a website or web application?” with the answers “Yes, Drupal as website and repository” or “No, Drupal as a repository for non-web applications only”.
If your answer to the previous question was “No”, then you should build a fully decoupled application, and your decision is complete. If your answer to the previous question was “Yes”, then ask the question “Are there things the project cannot live without?”
Both editorial and developer needs are things that projects cannot live without, and here are the questions you need to ask about your project:
- Do editors need to manipulate page content and layout without a developer?
- Do editors need in-context tools like in-place editing, contextual links, and toolbar?
- Do editors need to preview unpublished content without custom development?
- Do editors need content to be accessible by default like in Drupal’s HTML?
- Do developers need to have control over visual presentation instead of editors?
- Do developers need server-side rendering or Node.js build features?
- Do developers need data security driven by a publicly inaccessible CMS?
If, after asking all of these questions about things your project cannot live without, your answers show that your requirements reflect a mix of both editorial and developer needs, you should consider a progressively decoupled implementation, and your decision is complete.
If your answers to the questions about things your project cannot live without show that your requirements reflect purely developer needs, then ask the question “Is it a static website or a dynamic web application?” and choose among the answers “Static” or “Dynamic.” If your answer to the previous question was “Static”, you should build a fully decoupled static site, and your decision is complete. If your answer to the previous question was “Dynamic”, you should build a fully decoupled app, and your decision is complete.
Then, ask the second question, “Do you need to access multiple data sources via API?” and choose among the answers “Yes” or “No.” If your answer to the second question was “Yes”, then you should consider a progressively decoupled implementation, and your decision is complete. If your answer to the second question was “No”, then you should build a coupled Drupal site, and your decision is complete.