Maintaining Drupal's Power Features in a Decoupled World: Forms, Workflows, and More

The myth that “decoupled Drupal means losing Drupal” has been surprisingly persistent. 

Many developers, product managers, and decision-makers assume that once you decouple, you leave behind the very features that made you choose Drupal in the first place: powerful forms, robust access control, workflow management, content moderation… the list goes on.

But decoupling Drupal doesn’t mean discarding its core strengths. It means exposing them more flexibly.

As Octahedroid founder and CEO Jesus Manuel Olivas puts it in his webinar on Drupal Decoupled misconceptions, “You can still take advantage of all those awesome features from Drupal, even in a decoupled setup.”

Let’s break down how.

The Real Misconception: You Miss Important Features Like Webforms

This myth is rooted in the early stages of decoupled CMS adoption. 

When teams first started using Drupal as a headless backend, they focused heavily on exposing content via APIs, leaving complex features like forms and workflows behind.

As a result, people believed:

• Webforms wouldn’t work outside the Drupal front end.
• Content moderation was impossible to sync with decoupled apps.
• Access control would have to be rebuilt from scratch on the front end.

"People tend to worry about previews, revisions, content moderation, access control, and webforms," says Olivas. "But you can still take advantage of all those features from Drupal, even in a decoupled setup."

Drupal Features That Remain Intact (and Powerful)

Let’s look at some of Drupal’s most important features and how they hold up in a decoupled world:

1. Webforms in a Decoupled Setup

Yes, even complex Drupal Webforms work in decoupled environments. Here's the practical approach:

The process is straightforward:

1. Go to the webform UI and create your form (standard Drupal process).
2. Configure permissions and access control (again, standard Drupal).
3. Create your form on the frontend using React components.
4. Use the GraphQL Compose Webform module to pull form fields and settings.
5. Submit data back using the provided mutation.

"You can either hardcode your form fields manually or implement a process for generating the form based on that form configuration," explains Olivas. "Once you have the data back on submission, you're back to Drupal world, you can implement any handlers, post to CRM systems, or review submissions in the Drupal back office."

The key insight: You're not rebuilding form logic. You're just presenting it differently.

2. Access Control: Simple OAuth Integration

Drupal's role and permission system remains fully functional in decoupled setups.

"When you use the Simple OAuth module, you're connecting as a user with a certain role," notes Olivas. "Access control is just the same—instead of logging through the Drupal form, you log in a different way, but you act as a user with a certain role when interacting with the system."

This means:

• Private content stays private.
• Users only see what they're authorized to see.
• No need to rebuild RBAC from scratch.

3. Content Moderation & Workflows

Content moderation is one of Drupal’s most powerful editorial features—and it continues to work beautifully in decoupled setups.

Content moderation allows you to:

• Define custom states (Draft, Needs Review, Published, etc.).
• Create role-based transitions (e.g., only editors can publish).
• Trigger notifications and approvals within the moderation pipeline.

Previewing moderated content in the front end is also now possible via tokenized preview URLs or iframe-based previews, giving editors and stakeholders full visibility without affecting live content.

A Real-World Example: Decoupled Form with Workflow

Let’s say you’re launching a scholarship application form:

1. The front-end app (built in React) fetches the schema from Drupal.
2. The form renders with conditional logic: if the user selects "International Student," more fields appear.
3. On submit, the data is sent back to Drupal and stored as a Webform submission.
4. Moderators receive a notification to review and approve.
5. Once approved, data is sent to a CRM via webhook.

The entire experience, from form design to review to external system integration, is handled by Drupal, even though the user never touches a Drupal theme.

Why This Matters for Technical Leaders

If you're evaluating CMS platforms for enterprise projects, this changes the equation:

• You Don't Trade Features for Flexibility: Keep Drupal's editorial tools while using modern frontend frameworks.
• Your Workflows Remain Intact: No need to retrain content teams or rebuild approval processes.
• Development Teams Get the Stack They Want: React, Next.js, Vue, whatever works best for your frontend needs.

Getting Started: Remove the Friction

The traditional pain point hasn't been whether these features could work: it's been the complexity of setting them up.

That's exactly what Drupal Decoupled solves. "We have a way to deploy Drupal one-click so you can try frontend and backend at the same time," says Olivas. "You can have that easily, regardless if you have two systems, you can do that like easily."

Try it yourself:

• Visit the Drupal Decoupled site for a one-click preview.
• Test webforms, authentication, and content moderation in action.
• See how these features integrate with Next.js and Remix starters.

The Bottom Line

Decoupling isn't about losing Drupal's power: it's about using that power more flexibly.

"Give it a try," recommends Olivas. "It's not as hard as it sounds, and a lot of the things you think you're going to end up missing, it's not true. There are a lot of things already resolved."

The misconception that decoupling means losing functionality has held back too many teams from modernizing their architecture. The reality is simpler: you can have both Drupal's proven CMS capabilities and the frontend experience your users deserve.