Concrete CMS: When WordPress Is No Longer Enough and Writing Everything from Scratch in Laravel Feels Like Too Much

Know that feeling when a client asks for a "simple site," but a week of revisions later, the project turns into a monster with custom data types, a complex permission system, and the need to edit content right on the page? You open WordPress and realize you'll drown in plugins. You look at Laravel and understand you'll be writing an admin panel for three weeks. Somewhere in the middle lives Concrete CMS — a project with a long history that tries to sit on two chairs: give developers freedom and content managers convenience.

Previously the project was called concrete5. The rename to Concrete CMS happened a couple of years ago, which introduced some confusion in the repositories, but architecturally it's still the same solid PHP tool.

What Is It Anyway

Concrete CMS is an Open Source content management system written in PHP. To put it bluntly, it's a CMS for those who love object-oriented programming but don't want to spend time on basic things like authentication or file management.

The main feature people love (or hate, depending on perspective) is "in-context" editing. You go to the site, click the "Edit" button, and change blocks directly in the frontend interface. For clients, it's magic. For developers, it's an architecture built on blocks and pages.

What Can Hook a Developer

Unlike many systems that try to be "just a blog engine," Concrete was designed from the start as an application framework.

Flexible Block Management

In Concrete, everything consists of blocks. Want to create a new content type? You create a folder with a controller and a couple of View files. The system will automatically pick them up, create the necessary tables in the DB, and add them to the drag-and-drop interface. This is more convenient than dealing with Advanced Custom Fields in other systems.

Built-in Permission Management

It's not just "admin" and "editor" here. You can configure access to a specific block on a specific page for a specific user group at a specific time. Sounds excessive until you get a task to build a corporate portal for a 500-person company.

Life on the PHP Stack

The project actively uses modern standards. Under the hood, you'll find Composer for dependency management and Symfony components. This means you don't need to learn a "special PHP dialect," as is often the case with legacy systems.

How to Deploy the Project Locally

The project's README is quite concise, which is actually refreshing — no unnecessary fluff. Installation is classic for a PHP project.

First, clone the repository:

git clone https://github.com/concretecms/concretecms.git
cd concretecms/

Then pull in dependencies via Composer:

composer install

By the way, if you're used to Docker, the community has plenty of ready-made images, although the official repository doesn't highlight containerization instructions at the forefront. After installing dependencies, you'll need a web server (Apache or Nginx) and a MySQL database.

Technical Nuances and Legacy

The repository currently has the 9.x branch active. This matters because the transition from 8.x to 9.x was quite painful due to interface updates and internal library changes. If you've inherited a project on an old version, the repository has separate branches for 8.5.x and even 5.7.x.

Interesting point: Concrete CMS isn't shy about its age. The repository has existed since 2014, and the system itself is even older. This provides stability, but sometimes you can encounter solutions in the code that seem heavyweight by today's standards. On the other hand, the project has almost 500 open Issues. This can be intimidating, but if you look closer — there's active discussion of bugs and new features going on there, which for Open Source is more of a good sign than a bad one.

What Tasks Is It Good For

I wouldn't recommend using Concrete CMS for a small landing page — you'll spend more time setting up the environment than building the actual site. But it works great in these cases:

1. Complex corporate websites where different departments manage content.
2. Intranets and internal portals with tons of access permissions.
3. Projects where it's critically important for the client to see text edits immediately in the design, not in the admin panel.

Verdict: Should You Try It

If you're tired of the limitations of popular CMSs but Symfony CMF seems like an overly complex toolkit, Concrete CMS is an honest middle ground. It has a learning curve, and the documentation sometimes makes you sweat, but the flexibility it provides "out of the box" often pays back the time invested.

Best to start by exploring their documentation, and if something goes wrong — check the forum. The community there isn't as huge as WordPress's, but it's more engineering-focused and responsive.