What we did last year

Over the past year — through the Bucharest, Beethoven, Axolote, and Salamina sprints — the Plone community has been shaping Seven, the next-generation frontend that succeeds Volto.

We started reimagining the future of Plone's frontend. Seven isn't just Volto mark 2 — it's a new foundation for the next decade of Plone. Check my previous blog post for more context on the vision and goals.

This post summarizes what’s working today in Seven — the features and architectural foundations that are already taking shape — and how we got here through the combined sprint efforts.

A retrospective into the future

Before writing a single line of code, we took time to really look at Volto — not as something to replace, but as something to understand.

What made it powerful? What did developers love about it? What made it uniquely Plone?

But also — where did it start to show its limits? Where could we evolve? That reflection became the foundation for Seven.

We didn’t reinvent; we distilled.

We learned a lot from Volto — about what worked, what didn’t, and what the community needed. Seven grew out of that reflection.

We are aiming for these key architectural principles:

• Modularity: add-on oriented development, clear separation of features into packages.
• Performance: fast builds with Vite, minimal bundles, and optimized rendering.
• Flexibility: choose between using the default theming and core components, bringing your own design system, using Tailwind CSS for styling, or simply plain CSS.
• Developer Experience: Documentation and TypeScript first, streamlined setup, testing (unit/acceptance) and Storybook integration.
• Accessibility: a11y baked in from the start, not an afterthought.
• Upgradeability: smooth migration path from Volto, preserving data shapes and API contracts.
• Patterns: use familiar patterns introduced in Volto, but evolve them to be more composable and maintainable.

Public UI and CMS UI Separation

We are aiming for a clean separation between the Public UI (the site visitors see) and the CMS UI (the editing interface for content managers). This will allow you to deploy a lightweight Public UI without the overhead of the CMS features. This separation is a big architectural shift from Volto, where both UIs were tightly coupled.

You can already start Seven in public-only mode today. It’s not just theory anymore — it works.

Internationalization (i18n)

We’ve adopted i18next as the translation framework.

As of now:

• Language switching works in the public UI.
• Components consume translations through the unified hook.
• Locale and domain management are centralized and ready for CMS integration.
• Add-ons support i18n out of the box.

Contents view

We think the contents view is a crucial part of the CMSUI. It's the central piece for content management, and we want to get it right. Designed to be portable, it lives in its own package (`@plone/contents`), and can be reused in different contexts (for example, in a mobile native app, or in a desktop application using electron).

The basic contents view is already working, with accessibility in mind. Pagination, sorting, filtering, and bulk actions. There's an ongoing PR open, but in the last Salamina sprint, we made significant progress and we expect it to be merged soon.

Theming and Styling

The theming story in Seven has made huge progress. We’ve now separated Tailwind-based themes from base component styles — a key architectural decision made during Axolote.

The Agave theme (@plone/agave) demonstrates this: a fully Tailwind-driven look for the public UI, independent of CMS styling. This separation allows future themes to be swapped or customized without risk of cross-pollution between public and editing interfaces.

Styling is now predictable, composable, and isolated — a crucial step toward maintainable UI systems.

Redesigned and improved Authoring Experience

The blocks editor and the rich text block are both the heart of Plone’s authoring experience, and we’re rethinking them from the ground up.

First, we are adopting Plate.js as the rich text editor framework, which is built on top of Slate.js. Plate.js provides a solid foundation for building rich text editing experiences, with a plugin-based architecture that makes it easy to extend and customize. It has lots of plugins available, including support for collaborative editing, suggestions, AI integration, and more.

We are experimenting on different improvements over the current Volto authoring experience, for example, not creating a new block when pressing Enter in an empty one, allowing users to write multi-paragraph blocks..

The new rich text block is already functional, with support for basic formatting, links, images, and more. However, it is still a work in progress, and we are actively working on adding more features and improving the user experience.

The blocks editor right now is in place, but it does not allow managing blocks yet. We are working on it, and we expect to have a basic version working soon.

Migration and Compatibility

Seven has been built with compatibility in mind. We’re preserving core data shapes and API contracts from Volto wherever possible, to smooth migration from existing sites.

This includes:

• Same plone.restapi contract.
• Compatible block data and schema definitions.
• A migration path for existing add-ons, with tooling to gradually adopt the new structure.

The goal: no data migration needed, just a frontend and add-ons upgrade.

What’s Next

With the foundations now solid, upcoming work focuses on:

• Continue developing the missing default core blocks and default views for content types.
• Implement missing structural slots
• Block model v3 architecture and StyleWrapper support for it.
• Authoring experience (the block editor, rich text block, and sidebar).
• Plate.js integration for rich text editing.
• CMSUI
• Contents view
• Misc CMSUI views (Sharing, History, etc.)
• Browser content widget
• Integration with existing Public UI content
• Polish and complete theming story
• Refine Agave theme
• Refine default structural elements @plone/layout styling
• Build additional themes (e.g. CSS-based theme)
• Adopt React Server Components (RSC) paradigm.
• Minimize bundling and improve performance.
• A11y compliance in CMS UI.
• Polish and complete `@plone/components`:
• Better Storybook coverage.
• Documentation.

Thanks and Acknowledgements

The progress we’ve made this year is the result of an incredible collective effort — a true community achievement.

First, a huge thank you to all the sprinters who contributed code, ideas, documentation, testing, and feedback during the Bucharest, Beethoven, Axolote, and Salamina sprints.

Each sprint brought together developers, designers, and integrators who shared their time and expertise to move Seven forward. Your dedication, curiosity, and passion made this possible.

A special thanks to the companies and organizations that supported their team members to participate in sprints and development: RedTurtle, Eau de Web, kitconcept, and the Plone Foundation for its support.

I also want to give a special personal thanks to two people: in the first place, to Piero Nicolli, my partner in crime in this journey. Secondly, to Timo Stollenwerk for encourage and supporting in this project since the very beginning.

Finally, we’re not stopping here. Over the next year, we’ll host several sprints focused on polishing, extending, and documenting Seven — and we’ll keep pushing forward together as a community. The next chapter of Plone’s frontend story is already being written, one sprint at a time.

Here’s to everyone who is helping shape Seven — and to the work still ahead.