ExpressionEngine: a publishing CMS, read from its official docs

The only evidence used is the official ExpressionEngine documentation landing page, which is a short index of resources. It is not a technical specification, so many facts below are marked unknown on purpose.

What this project is

ExpressionEngine is a content management system. Its documentation site presents it as something you learn by building a site, and the project's own focus is described as a publishing CMS. It is a CMS product. It is not PHP core, not a standalone PHP runtime, not an async library and not a framework adapter. Compare the distinction between PHP the language and Drupal the CMS: PHP is the language and engine, while a CMS is an application built on top of it. ExpressionEngine sits on the application side of that line.

It also differs from a framework component set. Components give a developer building blocks to assemble into an application. A CMS product ships an application with editors, content storage and site-building concepts. Which PHP libraries ExpressionEngine uses internally is not stated in the supplied source, so this guide does not claim any.

What the source actually shows

The landing page lists these resources:

• Starter courses, in video and written form, that walk through building a first site from scratch.
• ExpressionEngine University tutorials.
• A partners directory of developers.
• Community channels: Slack, a forum and StackExchange.
• Quick Start, described as the big picture.
• Installation, described as quick to complete.
• ExpressionEngine TV for instructional videos.
• An e-commerce resource and an Add-Ons Store for extending the CMS.
• The project blog and a Change Log.

That is the extent of the evidence. It confirms the existence of installation documentation, add-ons and a change log. It does not give version numbers, PHP compatibility, license terms, prices or support policy.

Architecture and content model

The landing page does not describe internal architecture, templating syntax, database requirements or the content data model. This guide therefore does not invent channels, fields, templates or APIs. The practical advice is to read Quick Start first for the big picture, then the written starter course to see how content and presentation connect, and only then decide whether the model suits your project. The add-on store implies an extension mechanism, but how add-ons are built is unknown from this source.

Execution model: classic requests versus persistent workers

In the classic PHP request lifetime, the web server hands each request to PHP, which boots the application, handles the request and discards almost all in-memory state. A persistent worker instead boots once and handles many requests in the same process. Swoole and Open Swoole are separate projects that take that approach, and neither is part of ExpressionEngine.

The supplied source does not say how ExpressionEngine is meant to run, so assume nothing about persistent workers. Do not run it under one unless the official docs explicitly support it.

The reason for caution is state leakage. A persistent worker keeps static properties, singletons, service containers, open database connections, caches, and per-user data such as the current user, session or locale. If any of these survive between requests, one visitor's data can appear in another visitor's response. Safe worker designs reset or recreate request-scoped state after every request, close or validate connections, clear static caches, and recycle workers periodically. A CMS written for classic requests may rely on the process ending to clean up, which is exactly the assumption workers break.

Practical use cases

The assignment's focus is a publishing CMS, so the natural fit is a site where editors manage content that is shown on public pages. The starter courses and e-commerce resource suggest content sites and possibly shops, but the depth of each capability is unknown. Evaluate by building the starter course site and checking it against your own editorial workflow.

Installation approach

The docs link to an Installation page, and that page is the authority. It was not part of the supplied packet, so this guide gives no install commands, package names, archive names or Docker images. For the learning track, use PHP 8.4 where ExpressionEngine's documentation confirms support. PHP 8.5 is planned for the track, and compatibility with it is unknown. The example below is a preflight worksheet, not an installer. It checks your local PHP against requirements that you copy from the official Installation page.

Strengths and limitations

Confirmed strengths are modest and about learning support: official starter courses, a university-style tutorial site, several community channels, an add-on store and a change log. Limitations are mostly gaps in this evidence:

• Current version: unknown.
• Supported PHP versions: unknown.
• License and pricing: unknown.
• Support and deprecation status: unknown, so the lifecycle is marked unknown rather than current or historical.
• Performance characteristics: unknown, and no speed claims are made.
• Runtime requirements, database and web server needs: unknown.

Runtime-style PHP projects are not browser exercises, and neither is this CMS. Installing it needs a local PHP environment and likely network services.

Deployment

The supplied source gives no deployment guidance. Before deploying, read the official Installation and Quick Start pages and the Change Log. Keep any local development server bound to 127.0.0.1 rather than all interfaces. If your host uses PHP-FPM, never expose FastCGI to the public network, because only the web server should reach it. Back up content before upgrades, and check the Change Log first. Secrets such as database passwords belong in your host's configuration, never in a repository or lesson file.

Links

The official documentation at https://docs.expressionengine.com/ is the single source for this guide. Start with Quick Start, then Installation, then the written course.

{
  "source": "https://docs.expressionengine.com/",
  "minimum_php": null,
  "required_extensions": [],
  "notes": "Fill these values from the official Installation page. Leave minimum_php as null and the list empty if not confirmed."
}

<?php
declare(strict_types=1);

$path = __DIR__ . '/requirements.json';
$raw = file_get_contents($path);
if ($raw === false) {
    fwrite(STDERR, "Cannot read requirements.json\n");
    exit(1);
}

$req = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);

echo 'Local PHP version: ' . PHP_VERSION . PHP_EOL;
echo 'Learning track target (8.4+): ' . (version_compare(PHP_VERSION, '8.4.0', '>=') ? 'yes' : 'no') . PHP_EOL;

$min = $req['minimum_php'] ?? null;
if (!is_string($min) || $min === '') {
    echo "Minimum PHP for ExpressionEngine: unknown (not filled in)\n";
} else {
    $ok = version_compare(PHP_VERSION, $min, '>=');
    echo "Minimum PHP $min: " . ($ok ? 'satisfied' : 'NOT satisfied') . PHP_EOL;
}

$exts = $req['required_extensions'] ?? [];
if (!is_array($exts) || $exts === []) {
    echo "Required extensions: unknown (not filled in)\n";
} else {
    foreach ($exts as $ext) {
        $name = (string) $ext;
        echo "Extension $name: " . (extension_loaded($name) ? 'loaded' : 'MISSING') . PHP_EOL;
    }
}

cd preflight
php preflight.php