# Plone CMS

> Python-based enterprise CMS with powerful workflow capabilities.

- Category: CMS & Blogging
- Difficulty: intermediate
- Components: plone
- Tags: plone, python, enterprise, workflow, zope
- Source: https://docker.recipes/cms/plone

## Overview

Plone is a mature, enterprise-grade content management system built on Python and the Zope application server, first released in 2001. Known for its robust security model, sophisticated workflow engine, and multilingual capabilities, Plone has powered government websites, universities, and large corporations worldwide. Its architecture emphasizes content versioning, granular permissions, and enterprise-scale content governance that many organizations require for mission-critical web applications.

This Docker configuration combines Plone's modern headless backend with Volto, the React-based frontend that represents Plone's evolution into a decoupled CMS architecture. The plone-backend container serves content via REST API while plone-frontend delivers the user interface, enabling developers to leverage Plone's powerful content modeling and workflow capabilities with contemporary JavaScript frameworks. This separation allows for flexible deployment scenarios and better performance scaling.

Organizations with complex content approval processes, multi-departmental websites, or strict security requirements will find this stack particularly valuable. Government agencies, educational institutions, and enterprises that need detailed audit trails, advanced user role management, and compliance-ready content workflows can leverage Plone's battle-tested governance features while maintaining modern user experiences through the React frontend.

## Features

- Advanced workflow engine with customizable content approval processes and state transitions
- Granular role-based permissions system with object-level security controls
- Built-in content versioning and rollback capabilities for all content types
- Multilingual content support with translation workflows and language-specific publishing
- TTW (Through-The-Web) development capabilities for creating content types without coding
- Zope's ZODB object database providing ACID transactions and automatic conflict resolution
- Plone Registry for centralized configuration management across the entire site
- Add-on ecosystem with hundreds of community-developed extensions and integrations

## Use cases

- Government and municipal websites requiring strict content approval workflows and accessibility compliance
- University and academic institution portals with department-specific content management needs
- Corporate intranets with complex organizational hierarchies and document approval processes
- Non-profit organizations managing multilingual content across different regions and languages
- Publishing houses and media companies requiring editorial workflows and content scheduling
- Healthcare and pharmaceutical companies needing audit trails and regulatory compliance features
- Legal firms managing case documents with granular access controls and version tracking

## Prerequisites

- Docker and Docker Compose installed with at least 4GB RAM allocated to containers
- Port 3000 and 8080 available for frontend and backend services respectively
- Basic understanding of Python web applications and REST API concepts
- Familiarity with React development if planning to customize the Volto frontend
- Knowledge of Zope/ZODB concepts for advanced backend customization and add-on development
- Understanding of content management workflows and user role hierarchies for proper site administration

## docker-compose.yml

```yaml
services:
  plone:
    image: plone/plone-backend:latest
    container_name: plone
    restart: unless-stopped
    environment:
      SITE: mysite
      CORS_ALLOW_ORIGIN: "*"
    volumes:
      - plone_data:/data
    ports:
      - "8080:8080"
    networks:
      - plone-network

  frontend:
    image: plone/plone-frontend:latest
    container_name: plone-frontend
    restart: unless-stopped
    environment:
      RAZZLE_API_PATH: http://plone:8080/mysite
    ports:
      - "3000:3000"
    depends_on:
      - plone
    networks:
      - plone-network

volumes:
  plone_data:

networks:
  plone-network:
    driver: bridge
```

## .env

```bash
SITE=mysite
```

## Usage notes

- Docs: https://6.docs.plone.org/
- Frontend (Volto) at http://localhost:3000
- Backend REST API at http://localhost:8080/mysite
- Create admin: docker exec -it plone bin/adduser admin admin Manager
- Enterprise security: granular permissions, workflows
- Python/Zope ecosystem, highly customizable

## Troubleshooting

- CORS errors in browser console: Verify CORS_ALLOW_ORIGIN environment variable matches your access URL and restart containers
- Frontend shows 'Network Error' connecting to backend: Check that RAZZLE_API_PATH points to the correct backend container URL including site path
- Database IntegrityError on content creation: Stop containers, remove plone_data volume, and restart to reset ZODB database
- adduser command fails with 'No such file': Ensure you're running the command against the backend container, not the frontend container
- Slow performance on large sites: Increase Docker memory allocation and consider configuring Zope's ZServer thread count via environment variables
- Add-on installation fails: Mount a custom buildout configuration or use the official Plone image build process for persistent add-ons

