01 / Why this matters
Not everyone needs to become a Drupal expert.
Years ago, I put together a presentation called Drupal for frontend devs and other mortals. It opened with a slightly cheeky reassurance: even if you are not a frontend developer, it is okay. Not everyone is perfect.
That was the tone I wanted. Drupal is powerful, but when you arrive with a background in HTML, CSS and JavaScript, it can be a little intimidating. Suddenly people are talking about nodes, Views, blocks, regions and Twig templates as though everybody grew up speaking Drupal.
I was not setting out to teach every corner of the system. I wanted to share what had helped me on real projects, especially the ways frontend and backend developers could work together instead of handing problems back and forth.
The original talk used Drupal 8-era examples. I have refreshed the explanations here for modern Drupal and marked the things that have changed. The central idea has not aged much: the sooner we understand the shape of the system together, the less time we spend fighting it later.
02 / Working together
The problem was not the people. It was the hand-off.
Picture a familiar project. The frontend developer creates a polished HTML prototype. It looks right, the interactions work and the client is excited. Then the prototype is handed over to the backend developer, who has to make Drupal produce exactly that markup.
Now the real gymnastics begin. A custom template here, an override there, a small exception to deal with the fact that Drupal wants to render the page in a different way. It can work, but it often creates effort neither person intended.
Prototype first hand it over customise Drupal to fit.
Understand the markup Drupal produces, then design with that structure in mind.
Frontend and backend work from the same evolving Drupal experience, with shared decisions.
My first improvement was simply to stop treating Drupal as the final destination for someone else's prototype. We started looking at the output Drupal already produced and designing around the right structure. Better still, we brought frontend work into the running Drupal environment earlier.
That does not mean design should surrender to whatever markup happens to exist. It means the team should agree on what the experience needs and how Drupal will deliver it, before either side creates a mountain of rework.
03 / The Drupal map
Eight concepts that make Drupal far less mysterious.
Before worrying about code, learn Drupal's vocabulary. The names are more useful than they first appear, because each one tells you something about where content comes from and how it reaches the page.
An individual piece of content, such as an article or a standard page. Drupal has other kinds of entities too, so not everything is a node.
The recipe for a kind of content. An Article might have a title, body, image and category fields.
The individual pieces of information in that recipe: text, images, links, dates and more.
Organised labels and categories, such as topic terms, that help group and find content.
A way to select, filter, sort and display content. Think latest news lists, directories and archive pages.
Reusable pieces of page content or functionality, such as a featured article list or search box.
Places where page components can appear, defined by a theme or its layout approach.
The presentation layer that turns Drupal's content and structures into something people see and use.
One distinction is worth keeping: a content type defines the shape, while a content item is one example filled in by an editor. Taxonomy helps organise those items, Views can assemble a list, and a theme controls how they appear.
Once you can have that conversation with a backend developer, you are no longer guessing at what the frontend will receive.
04 / From content to screen
Follow one article from the editor to the browser.
Let's imagine a team publishing news. The editor creates a new Article, adds a headline, chooses a category and uploads a picture. Drupal stores that content in structured fields. A View finds the latest five published articles. The theme renders those items in a layout, using templates and styles.
This is a simplified picture. Drupal's render arrays, entities, cache and display configuration do a lot of important work under the bonnet. But as a mental model it is a useful starting point.
It also helps when something looks wrong. Is the field empty? Did the View exclude the item? Did the component receive the wrong data? Or is the CSS simply not doing what we hoped? Those are very different problems, and knowing the layers helps us diagnose them faster.
05 / Know your environment
Before you write CSS, know where the website actually runs.
One of my old slides had two diagrams. In the first, Drupal and the frontend prototype lived on your computer. In the second, the site ran on another server, so compiled files had to travel there. The diagrams were simple, but they explained a surprising number of "why can't I see my change?" moments.
The tooling has evolved. You may now be working with a container-based local environment such as DDEV, Composer to manage the project, Git to manage changes and Drush for Drupal administration. Another team may use a different setup. The names matter less than understanding the path.
Theme, components, CSS, JavaScript and configuration under version control.
Drupal running locally or in a shared development environment, with agreed build steps.
Inspect the output, clear relevant caches when necessary and test the actual components.
Ask where Drupal runs, where theme assets live, how changes are built, which caches are involved and how the work reaches a shared environment. Also ask what is safe to change. These five minutes of questions can save a very long afternoon.
06 / The theme files
Meet the files that connect the design to Drupal.
The older presentation called two files your new best friends. I still think that is a reasonable introduction.
mytheme.info.yml describes the theme and can declare regions, while mytheme.libraries.yml declares CSS and JavaScript assets that Drupal can attach where needed. Then Twig templates provide the markup.
Theme definition
name: My Theme
type: theme
base theme: false
core_version_requirement: ^10 || ^11
regions:
header: Header
content: Content
footer: FooterAsset library
global:
css:
theme:
css/site.css: {}
js:
js/site.js: {}The exact theme structure depends on your Drupal version and how the team builds components. The important principle is to let Drupal know what assets exist and attach them deliberately, instead of hiding everything inside one enormous JavaScript file.
For a reliable starting point, use the official Drupal theming guide and the documentation on adding JavaScript and asset libraries.
07 / Twig and markup
Twig controls presentation. It should not become a second backend.
Twig is Drupal's template language. If you know HTML, the first steps are approachable: write the markup, print values safely, and use straightforward conditions or loops where the template needs them.
One example from the original slides was page.html.twig, which determines how the page's regions sit in the document. In a simplified template, you might have:
<header>{{ page.header }}</header>
<main id="main-content">{{ page.content }}</main>
<footer>{{ page.footer }}</footer>
In practice, your theme will also handle attributes, semantics, accessibility and any layout needs. The point is that Twig describes the output, while Drupal prepares the content and structure behind it.
Views introduces another useful detail. A news listing might contain a wrapper, a header, a series of rows and a footer. Learn to inspect the actual rendered markup before adding template overrides. Drupal often gives you useful classes and template suggestions already.
My rule is simple: override a template because the markup needs to change, not because you want to add a class you could have handled another way. Work with your backend colleague on the right display mode, View configuration or component boundary before creating exceptions that will follow the project for years.
08 / What has changed
The slides are old. The principle is not.
The original presentation talked about Drupal 8, the Classy base theme, Gulp build tasks and older local stacks. Those were appropriate to that period, but I would not turn an old slide into a modern installation guide without revisiting it.
Modern Drupal projects may start with Starterkit-generated themes and use Single-Directory Components to keep a component's template, styling and behaviour together. SDC became part of Drupal core's render system in Drupal 10.3. These approaches can make shared design systems and frontend collaboration more natural, but you still need to understand what Drupal sends to the component.
Do not assume the old Classy inheritance pattern, a Gulp task or a particular command will suit every supported Drupal version. Check the version, theme architecture and team conventions first.
I also spoke about frontend and backend collaboration in my DrupalSouth talk. The vocabulary and tools change, but the message is similar: the best experience usually comes from people solving the same problem together.
09 / My golden rules
Planning, planning and, yes, a little more planning.
I used to finish this talk with a few rules. Some of the wording might have been more colourful in person, but the substance still holds up.
Sit with a backend developer. Decide what appears where, which parts are editable and how content will flow before building a forest of overrides.
Understand the rendered markup, display modes and available template suggestions. Change only what has a reason to change.
Make components understandable and reusable. Keep dependencies intentional and test them in the real Drupal context.
Frontend and backend are not competing teams. Share what you know, flag constraints and choose the route that gives the whole team the best outcome.
If you are new to Drupal, don't worry about learning every menu or template on day one. Understand the eight concepts, follow one piece of content through the system, get comfortable with the environment and find out who to ask when something behaves unexpectedly.
Drupal becomes a lot less intimidating when you stop treating it as somebody else's problem and start treating it as a shared product.