Introducing Seven: The Future of Plone’s Frontend
Seven is the successor to Volto.
"Seven" is just a codename for now—don’t worry, it’s not permanent. Among all the options we considered, this one stood out (and yes, naming things is always hard!). Once the project is complete and ready for release, it will receive a proper, permanent name.
After the Salamina Sprint, held in Ferrara in September 2024, we realized it was time to tackle some long-standing architectural issues in Volto. These problems stem mainly from obsolescence in some of Volto's core components:
Bundler and builder
Data acquisition layer
Router
Theming and design system
Global state management
Internationalization
To address these, we set out to define a series of Plone Improvement Proposals (PLIPs) focused on short- to mid-term improvements.
I spoke about this initiative during the Brasília Plone Conference—feel free to revisit the talk if you’d like more context.
These proposals aim to modernize each affected part of the architecture by replacing them with current, well-supported alternatives:
Switching to Vite as the new bundler
Updating to React 19, embracing its new data-fetching paradigm
Adopting @plone/components, built on top of react-aria-components
Using @plone/client for data fetching, combined with a modern routing library
Updating the libraries used for state management, internationalization, and other core architecture layers
After developing some proof-of-concepts—like the Vite as Volto bundler PLIP—we quickly realized the full scope of this transformation.
A Full Rewrite?
Modernizing Volto is no small task. The existing architecture is deeply rooted in a custom server-side rendering (SSR) system that would need to be entirely removed and replaced by a modern React 19 framework.
On top of that, the current data-fetching layer, based on Redux and asyncConnect, would also need to be replaced and rewritten from scratch.
Similarly, replacing Semantic UI with @plone/components would mean refactoring nearly every presentational component in the codebase.
In short: this kind of refactor would result in an entirely different application—code-wise, behaviorally, and visually.
Given this reality, and our limited resources, we reached a conclusion: rather than invest in a multi-year effort to refactor Volto, it would be more efficient and effective to channel that effort into building a new app from the ground up.
A Modular Foundation
This idea wasn’t born overnight. Some time ago, I began exploring what truly makes Volto Volto. I stripped it down to its essence and asked: If we had to rebuild Volto from scratch, what features, patterns, and principles would we keep?
I’ve given several talks on this topic at past Plone conferences—you can find them on the Plone YouTube channel.
In summary, the core elements are:
Add-ons architecture
Configuration registry
Component shadowing
Structural and basic UI components
Theming
Data fetching
Routing
Server-side rendering
Block editor
Once these pieces were identified, the next question was: Can we break them into standalone, reusable packages? If so, not only could Volto use them, but so could other frameworks.
Over the past few years, we’ve been doing exactly that—building these modular packages:
@plone/registry@plone/client@plone/components@plone/types
These are the puzzle pieces of the future Plone's frontend.
Meet Seven
In November, these packages had matured enough for us to take the next step: integrate them and begin building the next major version of Plone’s frontend.
Seven is the result of that initiative—a series of proof-of-concept experiments using the modular frontend architecture we've envisioned.
Key Features
1. Built on React Router 7
Seven uses the latest version of React Router, embracing modern routing patterns including nested routes, layouts, and enhanced data loading capabilities. This brings better performance, code splitting, and simpler mental models.
2. Modular by Design: Everything is an Add-on
Seven is designed to be 100% pluggable. Core functionality is split into self-contained add-ons such as:
@plone/publicui– Public-facing UI layout routes@plone/cmsui– Authenticated authoring CMS interface@plone/blocks– Block editor functionality and core blocks@plone/slots– Slot-based UI composition@plone/theming– Theme support and customization@plone/contents– Content management view and controls
You can create custom builds with only the features you need. Want a public-only UI without CMS? No problem.
3. Data Fetching with React 19 Paradigm
Seven adopts the new data-fetching model introduced in React 19, moving away from Redux and asyncConnect to a native and streamlined approach using loaders and actions. Data flows are simpler, faster, and more predictable.
4. Accessibility-First UI with @plone/components
The UI layer is built on top of @plone/components, which leverages react-aria-components under the hood. This ensures accessible-by-default components and a robust, WAI-ARIA-compliant interface out of the box.
5. Registry-Driven Configuration via @plone/registry
The app configuration is driven by @plone/registry, making feature toggling, customization, and add-on registration seamless and centralized. In Seven, every feature is an add-on. The app itself is just the glue.
6. Improved Developer Experience
Seven introduces better DX with:
Storybook integration for component previews and live documentation
Modern, framework-native conventions with minimal custom plumbing
Same familiar Volto configuration and patterns conventions
7. Themability and Custom UI Support
You can bring your own component library or design system and wire it into the app easily. Whether you're building a highly customized experience or a white-labeled frontend, Seven won’t get in your way.
8. Performance-Oriented Architecture
With a Vite-based build, automatic code splitting, Seven will deliver a lightweight and highly performant experience, especially for public-facing pages.
9. Forward-Compatible & Volto-Compatible
Seven is designed to preserve the core data structures, patterns, and behavior of Volto. We’re committed to making the transition as smooth as possible in three key areas:
Data migration: We aim for no migration required
Authoring experience: Built on Volto’s UX, with enhancements inspired by Quanta UI. All changes will be documented with videos and guides.
Developer experience: Changes and new capabilities will be clearly documented, while maintaining a familiar developer experience.
10. Quanta UI Exploration
We are evaluating new UI/UX patterns inspired by Quanta UI. While Seven remains rooted in Volto’s authoring principles, future enhancements will explore bringing in modernized workflows, UI layouts, and microinteractions.
11. Same Deployment, Same Tooling
Deployment and project setup remain familiar: Cookiecutter Plone and pnpm monorepo structure. This keeps the learning curve shallow for existing teams.
References & Demos
For the World Plone Day 2025, I authorede a video talking about the subject of this post:
Seven is being developed in this branch:
👉 github.com/plone/volto/tree/seven
You can try a working public UI demo here:
🔗 seven.sneridagh.dev
Compare it with the current Volto site:
🔗 sneridagh.dev
There’s also early work on the CMS UI—basic login and edit forms are already functional.
📚 WIP documentation for Seven:
👉 volto.readthedocs.io/seven