- Nov 21, 2025
- --
A headless redirect strategy for IT and Editors
Why editor-managed redirects in Admin Central are the key to headless agility.
-
Martin HaderkaFrontend Developer, Magnolia
Experience Magnolia in action
Experience Magnolia's key features firsthand in an interactive product tour.
Take a tour nowTL;DR
- Organizations face a "two-level" redirect problem: IT needs to manage complex, structural rules for performance/governance, while editors need agility to create vanity URLs and fix 404s instantly without IT tickets .
- Magnolia enables a hybrid approach. IT manages high-volume rules via the Platform/Cockpit, while simple redirects are treated as content managed by editors via a dedicated "Redirects App" in Admin Central .
- In headless setups (like Next.js), the frontend middleware consumes this editorial redirect data via API, ensuring high performance and instant updates via webhooks .
Managing URL redirects is a critical, everyday task for any digital experience platform. When a page moves, a product is renamed, or a marketing campaign launches with a short, "vanity" URL, you need to seamlessly redirect users.
But this simple need often exposes a core challenge in enterprise-level content management: Who should be responsible for creating and managing these redirects?
Is it an IT or DevOps task, managed deep in the platform configuration? Or is it a business task, managed by an editor or marketer directly in the GUI?
The answer should be ‘both’ for a truly flexible DXP. This is where Magnolia's hybrid approach to content and platform management comes into play, especially in a headless configuration. As an enterprise-class solution, Magnolia can handle numerous redirects simultaneously.
The two-level redirect challenge
In any large, global organization, you'll encounter two distinct types of redirect needs:
The Platform/IT level: This is about governance, stability, and high performance. It involves site-wide, structural, or highly technical redirect rules. Think complex regex patterns, managing multiple domain mappings, or implementing hundreds or thousands of redirects during a major site migration.
For this, our DX Cloud documentation, recommends using the platform's cockpit for managing redirects at scale. This level is optimized for bulk uploads (like CSV) and maximum performance, ensuring that a high volume of rules doesn’t impact site speed. This is a crucial distinction from older documentation benchmarks; this level is designed for enterprise scale not just a handful of rules.
This "IT-level" control is a strength of Magnolia, where developers can also use our core Virtual URI Mapping capabilities to configure forward:, redirect:, or permanent: actions via simple YAML definitions. This is a robust, developer-driven solution that is perfect for permanent, structural changes to a site.
The Editor/Business level: This is the day-to-day reality for most marketing teams. A regional editor in the APAC market needs to create a simple vanity URL for a new campaign today. A content manager in Europe notices a 404 on a high-traffic page and needs to fix it, now. They cannot, and should not, be expected to file an IT ticket and wait.
In these scenarios, editors must be able to create and manage redirects directly within the DXP's GUI—without ever touching platform management or configuration files. This is not only for agility but is often a strict information security requirement, as it prevents giving editorial teams access to administrative layers they shouldn't need.
Finding the right balance: The Magnolia advantage
This two-level problem often presents a false choice in the DXP market.
Some simpler, pure-SaaS providers might seem to make this easy with a simple redirect manager in their GUI. However, this often masks a lack of deeper, platform-level control for high-performance or complex rules. Conversely, many enterprise DXPs that offer both levels often force editors to use a separate, technical "admin" tool, creating security and training hurdles.
Magnolia is in a unique position to deliver on all fronts:
For headless (The Content App): As we'll show, you can empower editors with a secure, custom-built app inside Admin Central.
For traditional sites (MTK): We've long-provided this balance in traditional, Freemarker-based (MTK) development, where our Redirect Template allows editors to create a new "page" that is actually just a simple redirect. This is a powerful, out-of-the-box solution for non-headless projects.
For platform power (DX Cloud Cockpit / YAML): We provide robust, high-performance tools for IT to manage thousands of rules.
This flexibility means you don't have to compromise. You can provide a simple, secure UI for editors in the same Admin Central they use every day, while IT retains the powerful, high-performance controls they need.
The solution: Editor-managed redirects for headless
Instead of treating redirects as a platform-only configuration, we can treat them as content. And if it's content, editors in Magnolia can manage it.
The most effective way to handle day-to-day redirects in a headless setup is to create a "Redirects" Content App directly in Magnolia Admin Central.
This approach gives editors a simple, secure, and familiar interface for managing simple redirects and vanity URLs, which are then consumed as data by your headless frontend (e.g., a Next.js or Angular application).
A practical guide: Building an editor-managed redirect system
The following guide outlines the core principles for this solution. We’ve made a complete, runnable demo project available on GitLab, which uses a Next.js frontend as a concrete example. The core concepts—creating a content app, fetching data via an API, and handling requests—can be applied to any headless frontend (e.g., Angular, Vue, Svelte).
You can find the complete demo project and setup instructions here:
Step 1: Create the 'Redirects' Content App
First, using a simple light module, you define a new content type and a content app. The content type defines the data structure for your redirects (e.g., from, to, and code fields). The content app provides the GUI for editors to manage this data.
Step 2: Editors manage redirects as content
Once the light module is installed, your editors and marketers will see a new "Redirects App" in their Magnolia menu. (Note: This is a good place to update screenshots to reflect the modern Admin Central UI.)
They can now add, edit, publish, and unpublish redirects just like they would a news article. This workflow is secure, permission-based, and requires zero IT involvement.
Step 3: Expose the redirects via API
To make these redirects available to your headless app, you create a simple REST delivery endpoint (or use GraphQL). This makes the redirect data available as a simple JSON object for your frontend to consume.
Step 4: Consume redirects in the headless App (Next.js example)
This is the magic. Using a feature like Next.js Middleware, your application's server checks every incoming request before it tries to render a page. It quickly compares the requested path against its list of redirects.
If a match is found, the middleware instantly issues the correct HTTP redirect (e.g., a 301 redirect to /my-new-page) and the rendering process stops. This is extremely fast and efficient.
Step 5: Webhooks keep the list fresh
To ensure new redirects go live instantly, you configure a Magnolia webhook. When an editor publishes a new redirect, the webhook pings a specific endpoint in your headless application, telling it to clear its cache and refetch the redirect list.
The best of both worlds
This solution perfectly embodies Magnolia's flexibility:
IT & DevOps still control the powerful, platform-level redirects for site structure, security, and bulk operations.
Editors & Marketers are empowered with an in-GUI tool to manage the agile, day-to-day business needs from within Admin Central.
You don't have to choose between platform power and editorial agility. With Magnolia, you get both.
