Expert Joomla guides
Tutorials, upgrade notes and AI workflows for people who build and run Joomla sites.
Joomla won Favourite Open Source CMS at the 2025 20i FOSS Awards, the community-voted awards run by the UK hosting company 20i for free and open-source software. It's a popularity vote, not a benchmark, and that's what makes it interesting. The people who voted are the people who build and run sites with it.
What the vote rewarded
In mid-2025 Joomla 5 was the current version, and the things users noticed were mostly under the hood:
- Upgrades that were boring for once. After the long Joomla 3 → 4 rewrite, 4.4 → 5 was an update with a compatibility plugin, not a migration. For agencies with dozens of sites, that's the feature.
- Core features that used to need extensions: schema.org structured data, multi-factor authentication with passkeys, a task scheduler, a REST API, custom fields, workflows.
- Security and accessibility as defaults, with a dedicated security team and an admin interface built for WCAG.
- Multilingual in core, which is still unusual among the big open-source CMSs.
A year later: did it hold up?
Since the award, Joomla 6.0 shipped in October 2025, followed by 6.1 and 6.2. From our side, as developers who upgraded our own site and client sites:
- The 5.4 → 6 upgrade followed the same pattern as 4.4 → 5: a compatibility plugin, a clear deprecation log, and few surprises in core. The surprises came from extensions, as they always do. Our notes are in the migration runbook.
- Joomla 6 added automated core updates, child templates by example (Cassiopeia Extended), versioning that covers fields and tags, a third-party-free CAPTCHA (6.1) and security flags for extension updates (6.2). Details in what's new in Joomla 6.
- Work on Joomla 7 has started in the open, and its direction is clear: removing the compatibility layers kept since Joomla 4. Our take is in why Joomla 7 matters.
Why an award matters to developers at all
Clients ask whether Joomla is "still alive" more often than they ask about features. A community award doesn't answer technical questions. It does answer that one, which is often the question that decides whether a project is built on Joomla at all. A predictable release cycle, two-year majors with documented deprecations and long security support, answers the rest.
Congratulations to everyone who contributes code, tests, translations and documentation. The win is theirs.
Building on Joomla? We've done it for twenty years: new sites, migrations, custom extensions and long-term maintenance.
Our Joomla services →
Joomla 5 and Joomla 6 look almost identical in the back end. The differences are underneath, and they decide how much an upgrade costs. These are the ten we check on every 5 → 6 project, ordered by how often they turn up as real work.
1. PHP 8.3 is the floor
Joomla 5 runs on PHP 8.1 and up. Joomla 6 refuses to start below 8.3.0. Every page shows the "incompatible PHP" notice, so there is no gradual failure to catch on a test page. Two things follow:
- Switch PHP to 8.3 on Joomla 5.4 first, and let the site run on it for a week. Joomla 5.4 supports 8.3, so any extension that breaks is a PHP problem, not a Joomla 6 problem, and you've separated the two.
- Check the CLI PHP version too. Cron jobs and the Scheduler often run on a different binary than the web server.
# terminal – web and CLI must match
php -v # the CLI binary cron uses
which php # and where it lives
# the web PHP: System → System Information → PHP Version
2. Old class names are off by default
On Joomla 5, JFactory::getUser() works and logs a deprecation. On a fresh Joomla 6 install it's a fatal "class not found", because the ≈450 J* aliases moved into the "Behaviour – Backward Compatibility 6" plugin and its "Classes Aliases" option is off. Upgraded sites need the same check. This is the most common reason an extension "breaks on Joomla 6", and often the only one. The code fixes are in Joomla 6 for extension developers.
3. Filesystem and Input classes moved
Joomla\CMS\Filesystem\* and Joomla\CMS\Input\* are now provided by the compat plugin, and the replacements in the Joomla Framework throw exceptions where the old classes returned false. Upload handlers and importers are where this shows up. They work until the first failure, and then the error handling never runs.
4. Some front-end assets are gone
chosen (the old enhanced select) and wcpolyfill were removed. The compat plugin registers empty stubs, so there's no error message, just a plain <select> where a searchable dropdown used to be. Check the forms of older extensions by eye.
5. Template overrides compared against new core layouts
Joomla 6.2 changed the article image layouts (separate image and figure classes), and several components changed their default layouts across 6.0–6.2. After the upgrade, System → Templates shows which overrides have "changes found". Compare each one. The image layouts and the article/category blog layouts are the ones we rebuild most often.
6. Featured articles in the back end
Featured Articles is now a filter of the Articles list (view=articles&filter[featured]=1). The upgrade fixes the core admin menu, but custom admin menu items and editor bookmarks to view=featured need updating. The front-end featured menu item type is unchanged.
7. Versioning stores more
A saved version now includes custom fields, tags and the category, and modules get versions too (6.1). That's good for editors, but on a site with many fields and frequent saves the #__history table grows faster. Set "Maximum Versions" deliberately. Versions saved before the upgrade are marked is_legacy and don't contain field data.
8. Updates can install themselves
Joomla 6 can apply core updates automatically, using signed update metadata (TUF). For a site with overrides, a shop or a CRM we leave it off and update after a staging run. For a simple brochure site it's a reasonable default. Extension developers can now also flag a release as a security update with a severity (6.2), which the dashboard highlights.
9. Spam protection without a third party
Joomla 6.1 added a proof-of-work CAPTCHA plugin. No Google, no cookie, no API key. If your Joomla 5 site uses reCAPTCHA only because core had nothing else, the upgrade is a good moment to drop it, along with the consent-banner entry that comes with it.
10. Support timeline
| Version | Status (October 2026) |
|---|---|
| Joomla 5.4 | security fixes until October 2027 |
| Joomla 6.x | current; new features in 6.x minor releases |
| Joomla 4.4 and older | end of life, no security fixes |
Joomla 5.4 is not urgent to leave. It is urgent to have a plan, because extension vendors move their attention to 6.x well before 5.4 ends.
Before you decide: run the pre-update check
When Joomla Update on 5.4 offers the Joomla 6 upgrade, it runs a pre-update check first. It lists every third-party extension with a compatibility status from its update server: compatible, not compatible, or unknown. "Unknown" usually means the vendor doesn't publish Joomla 6 data. Treat it as "not compatible" until you have tested it.
For a quick inventory outside the back end:
# terminal – third-party extensions with their versions (adjust the table prefix)
mysql -e "SELECT type, element, folder, JSON_UNQUOTE(JSON_EXTRACT(manifest_cache, '$.version')) AS version,
JSON_UNQUOTE(JSON_EXTRACT(manifest_cache, '$.author')) AS author
FROM jos_extensions
WHERE JSON_UNQUOTE(JSON_EXTRACT(manifest_cache, '$.author')) NOT IN ('Joomla! Project', 'Joomla! Projects')
ORDER BY type, element;" mydb
Our upgrade order
- PHP 8.3 on Joomla 5.4, one week in production.
- Update every extension to its latest 5.x release, and replace the ones with no Joomla 6 plan.
- On staging: upgrade to Joomla 6, turn on Debug and Log Deprecated API, and click through the site.
- Fix the deprecations, review the overrides, then decide whether the compat plugin options can be turned off.
- Upgrade live in a quiet window, with a backup you have actually restored once.
If the site runs a shop or a CRM, check that piece first: VirtueMart on Joomla 6 and CiviCRM on Joomla 6 each have their own timeline.
Not sure your site is ready for Joomla 6? We run the checks above on a copy of your site and send you the list of what breaks, with a fixed quote to fix it.
Joomla 6 migration →
We first wrote this post about the Joomla 6 alpha. Joomla 6 is now at 6.2, and we have moved our own site and several client sites to it, so here is the version we wish we had read then: the changes in Joomla 6 that break extension and template code, how to find them in a codebase, and the replacement for each.
Everything below was checked against the Joomla 6.2 source, not the release notes.
The short version
| Old code | Joomla 6 status | Use instead |
|---|---|---|
JFactory, JText, JHtml, JRoute … (≈450 aliases) | removed from core; only via the compat plugin, off on new installs | namespaced classes: Factory, Text, HTMLHelper, Route |
Joomla\CMS\Filesystem\File, Folder, Path | moved to the compat plugin | Joomla\Filesystem\File, Folder, Path |
Joomla\CMS\Input\Input | moved to the compat plugin | Joomla\Input\Input |
CliApplication scripts in /cli | moved to the compat plugin | a console command in cli/joomla.php |
$db->getQuery(true) | deprecated | $db->createQuery() |
Factory::getUser(), getDbo(), getCache() … | deprecated since 4.3, removed in 7.0 | $app->getIdentity(), the DI container |
chosen, wcpolyfill assets | removed (empty stubs in the compat plugin) | choices.js via the fancy-select field |
Legacy plugins (plgSystemFoo with method-name events) | still work, deprecated | SubscriberInterface + event objects |
The compatibility plugin: what it does and doesn't do
Joomla 6 ships Behaviour – Backward Compatibility 6 (plg_behaviour_compat6) with three options:
- Classes Aliases, off by default. It loads
classmap.php, which registers the oldJ*names. Every alias in it is tagged "6.0", meaning it was removed from core in 6.0. - Include Deprecated Classes, on by default. It registers
plugins/behaviour/compat6/classesunder theJoomla\CMSnamespace, which brings backFilesystem,Inputand the old CLIApplicationclasses. - Removed Assets, on by default. It adds empty
chosenandwcpolyfillassets so$wa->useScript('chosen')doesn't throw.
Two things we learned on real upgrades. First, a fresh Joomla 6 install has Classes Aliases off, so an extension that works on an upgraded site can fatal-error on a new one. Test on both. Second, these classes are tagged for removal in 7.0. The plugin buys you time, it doesn't fix anything. On our own site, two commercial extensions (a subscription component and a forum) still need the aliases on Joomla 6.2. That is the most common situation you'll meet.
Find the problems before you upgrade
Run this from the extension's root. It's crude, but it catches most of the list above in seconds:
# terminal
grep -rnE "\bJ(Factory|Text|Html|Route|Uri|Table|Model[A-Z]?\w*|View\w*|Controller\w*|Plugin|Log|Date|Language|Session|User|Access|Form\w*|Registry|Filter\w*)\b" --include=*.php .
grep -rnE "Joomla\\\\CMS\\\\(Filesystem|Input)\\\\" --include=*.php .
grep -rnE "getQuery\(true\)|Factory::(getUser|getDbo|getSession|getLanguage|getDocument|getCache)\(" --include=*.php .
grep -rnE "useScript\('(chosen|wcpolyfill)'|HTMLHelper::_\('formbehavior\.chosen" --include=*.php .
Then test with Debug System on and Log Deprecated API on (System → Global Configuration → Logging). Click through every view of the extension and read administrator/logs/deprecated.php. It lists each deprecated call with the file and line, including the calls that grep misses because the class name is built dynamically.
1. Class aliases: the mechanical part
// before – works only with "Classes Aliases" on
$user = JFactory::getUser();
$title = JText::_('MOD_EXAMPLE_TITLE');
$link = JRoute::_('index.php?option=com_example&view=items');
echo JHtml::_('date', $item->created, JText::_('DATE_FORMAT_LC3'));
// after – Joomla 4.0 and later
use Joomla\CMS\Factory;
use Joomla\CMS\HTML\HTMLHelper;
use Joomla\CMS\Language\Text;
use Joomla\CMS\Router\Route;
$user = Factory::getApplication()->getIdentity();
$title = Text::_('MOD_EXAMPLE_TITLE');
$link = Route::_('index.php?option=com_example&view=items');
echo HTMLHelper::_('date', $item->created, Text::_('DATE_FORMAT_LC3'));
Note getIdentity() instead of Factory::getUser(). Swapping JFactory for Factory makes the code run on Joomla 6, but every deprecated Factory::get* call is another fix waiting for Joomla 7. Do both in one pass.
2. Filesystem: same names, different behaviour
This is the one that causes bugs rather than fatal errors. The framework classes are not drop-in replacements: they throw exceptions where the old CMS classes returned false and queued an error message.
// before – Joomla\CMS\Filesystem\File
use Joomla\CMS\Filesystem\File;
if (!File::delete($tmpFile)) {
$this->setError('Could not remove the temporary file'); // never reached on Joomla 6
}
// after – Joomla\Filesystem\File (framework package)
use Joomla\Filesystem\Exception\FilesystemException;
use Joomla\Filesystem\File;
try {
File::delete($tmpFile);
} catch (FilesystemException $e) {
$this->getApplication()->enqueueMessage('Could not remove the temporary file', 'warning');
}
Also check File::exists() and Folder::exists(). In most code a plain is_file() or is_dir() is clearer and has no dependency.
3. Input: change the type hints
$app->getInput() is declared to return Joomla\Input\Input. Code that type-hints the old CMS class still runs while "Include Deprecated Classes" is on. With it off, or on Joomla 7, it fails with a TypeError.
// src/Helper/ExampleHelper.php
use Joomla\Input\Input; // was: Joomla\CMS\Input\Input
public static function getFilters(Input $input): array
{
return [
'category' => $input->getInt('catid'),
'search' => $input->getString('filter_search', ''),
];
}
While you're there, replace $app->input (a magic property) with $app->getInput(). Static analysis can follow a method call, not a magic property.
4. Database queries: createQuery()
getQuery(true) still works, but the $new parameter triggers a deprecation in the database package. createQuery() always returns a fresh query object:
// src/Model/ItemsModel.php
$db = $this->getDatabase();
$query = $db->createQuery() // was: $db->getQuery(true)
->select($db->quoteName(['id', 'title', 'alias']))
->from($db->quoteName('#__example_items'))
->where($db->quoteName('state') . ' = 1')
->order($db->quoteName('ordering') . ' ASC');
In models, use $this->getDatabase() (from DatabaseAwareTrait), not Factory::getDbo(). It also makes the model testable, because the database can be injected.
5. CLI scripts become console commands
Standalone scripts in /cli that extend CliApplication only run while the compat plugin provides that class. The supported way is a console command, registered by a plugin and run through cli/joomla.php. That gives you options, help text and exit codes for free:
// plugins/console/example/src/Extension/Example.php
namespace Example\Plugin\Console\Example\Extension;
use Example\Plugin\Console\Example\Command\CleanupCommand;
use Joomla\Application\ApplicationEvents;
use Joomla\Application\Event\ApplicationEvent;
use Joomla\CMS\Plugin\CMSPlugin;
use Joomla\Event\SubscriberInterface;
final class Example extends CMSPlugin implements SubscriberInterface
{
public static function getSubscribedEvents(): array
{
return [ApplicationEvents::BEFORE_EXECUTE => 'registerCommands'];
}
public function registerCommands(ApplicationEvent $event): void
{
$event->getApplication()->addCommand(new CleanupCommand());
}
}
// plugins/console/example/src/Command/CleanupCommand.php
namespace Example\Plugin\Console\Example\Command;
use Joomla\Console\Command\AbstractCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
final class CleanupCommand extends AbstractCommand
{
protected static $defaultName = 'example:cleanup';
protected function configure(): void
{
$this->setDescription('Delete expired example items');
$this->addOption('days', null, InputOption::VALUE_REQUIRED, 'Older than N days', 30);
}
protected function doExecute(InputInterface $input, OutputInterface $output): int
{
$io = new SymfonyStyle($input, $output);
// … delete rows older than (int) $input->getOption('days')
$io->success('Done');
return Command::SUCCESS;
}
}
# terminal
php cli/joomla.php example:cleanup --days=60
For recurring jobs, a task plugin for the Scheduler is usually better than a command plus a crontab line, because it is configurable in the back end and logged. Commands are for things you run by hand or from a deploy script.
6. Assets: chosen is gone
If a form or layout calls HTMLHelper::_('formbehavior.chosen') or useScript('chosen'), Joomla 6 renders a plain <select>. Thanks to the stub asset there's no error, so it's easy to miss. Use the core fancy-select field, which is built on choices.js:
<!-- forms/filter_items.xml -->
<field
name="tag"
type="tag"
mode="nested"
layout="joomla.form.field.list-fancy-select"
multiple="true"
label="JTAG"
/>
7. Plugins: move to SubscriberInterface now
Legacy plugins (a plgSystemFoo class whose public methods are matched to event names) still run on Joomla 6. They are the next thing to go, and a plugin that implements SubscriberInterface works on Joomla 4.4, 5 and 6 alike, so there's no reason to wait. The full before/after, with the service provider and event objects, is in Joomla 6 plugin events explained with a CiviCRM example.
Template overrides
Overrides are code too. After the upgrade, open System → Templates → (your template) and look for the "Changes found" notice: Joomla flags overrides whose core layout changed in the update. In Joomla 6.2 the intro/full-text image layouts changed (separate image and figure classes), so overrides of layouts/joomla/content/intro_image.php and full_image.php are the first to compare.
A version policy that keeps one codebase
For our own extensions we support the current and the previous major version from one codebase: today Joomla 5.4 and 6.x, PHP 8.1+. Everything in this post works on both, because every replacement above exists since Joomla 4.x. The manifest says so:
<!-- mod_example.xml -->
<extension type="module" client="site" method="upgrade">
<name>mod_example</name>
<version>3.0.0</version>
<namespace path="src">Example\Module\Example</namespace>
…
</extension>
<!-- update XML -->
<targetplatform name="joomla" version="(5\.4|6)\..*"/>
<php_minimum>8.1</php_minimum>
Once your code passes the grep above and leaves deprecated.php empty, it is ready for Joomla 6 and most of the way to Joomla 7. What Joomla 7 removes next is in Joomla 7 breaking changes.
An extension that won't run on Joomla 6? Whether it's yours or abandoned by its vendor, we port it, keep your data, and hand you code that runs on 5.4 and 6.
Custom extension development →
Joomla's Media Manager accepts WebP and AVIF images in current versions (5.x and 6.x). That's where most articles about it stop. In practice, uploading AVIF files is the easy part. Whether Joomla can process them depends on how PHP was built, and serving modern formats to every visitor, with a fallback for the rest, takes a little template work. This post covers both, from what we do on client sites.
What Joomla supports out of the box
| Where | WebP | AVIF |
|---|---|---|
| Media Manager upload (default allowed extensions) | yes | yes |
MIME check on upload (image/webp, image/avif) | yes | yes |
| Crop / resize / rotate in the Media Manager editor | yes, if GD has WebP | only if GD has AVIF |
Joomla\CMS\Image\Image (thumbnails, your own code) | yes | only if imageavif() exists |
| Automatic conversion of JPEG/PNG on upload | no, Joomla stores what you upload | |
The defaults live in the Media component options: "Legal Image Extensions" is bmp,gif,jpg,jpeg,png,webp,avif, and the legal MIME types include image/webp and image/avif. If AVIF uploads fail on an older site, those two fields were probably saved before AVIF was added. Compare them with the defaults.
The catch: GD without AVIF
PHP's GD extension only supports AVIF when it was compiled against libavif. Many hosting builds and local stacks don't have it. Our own local MAMP PHP 8.3 is one of them. Check:
# terminal – the PHP the web server uses may differ from the CLI one; check both
php -r 'print_r(array_intersect_key(gd_info(), array_flip(["GD Version", "WebP Support", "AVIF Support"])));'
When "AVIF Support" is empty, the Media Action – Resize plugin, which shrinks large uploads to a maximum width and height, skips AVIF files without an error: it checks function_exists('imageavif') and returns. A 6000 px AVIF goes into images/ untouched, and nobody notices until the page weight does. On such servers, convert and resize before upload, or ask the host for a PHP build with libavif. Imagick with an AVIF-capable ImageMagick is an alternative for your own code.
Converting existing images
Joomla won't convert your existing library, and it shouldn't do it on upload either. That would cost CPU on every request that triggers it. We convert on the command line, keep the originals, and put the modern versions next to them:
# terminal – WebP and AVIF next to each JPEG/PNG under images/ (needs cwebp and avifenc)
cd /var/www/example.com/images
find . -type f \( -iname '*.jpg' -o -iname '*.jpeg' -o -iname '*.png' \) -print0 |
while IFS= read -r -d '' f; do
[ -f "$f.webp" ] || cwebp -quiet -q 80 "$f" -o "$f.webp"
[ -f "$f.avif" ] || avifenc --min 20 --max 30 -s 6 "$f" "$f.avif" >/dev/null
done
Naming the files photo.jpg.webp and photo.jpg.avif, rather than photo.webp, keeps the mapping trivial. Content keeps pointing at photo.jpg, and the server or the template picks the best file.
Serving them: two options
Option A: content negotiation in the web server
No template change. The browser says what it accepts, and nginx serves the best existing file under the original URL:
# /etc/nginx/conf.d/image-formats.conf
map $http_accept $img_suffix {
default "";
"~*image/avif" ".avif";
"~*image/webp" ".webp";
}
# /etc/nginx/sites-available/example.com
location ~* ^/images/.+\.(jpe?g|png)$ {
add_header Vary Accept;
try_files $uri$img_suffix $uri =404;
expires 30d;
}
Vary: Accept is essential. Without it, a CDN or proxy caches the AVIF version and serves it to a browser that can't read it. Some CDNs ignore Vary on images, so check yours, or use option B.
Option B: <picture> in a layout override
The HTML lists every format, and the browser picks the first it supports. It works behind any CDN. For article images, override the layout that renders them:
// templates/yourtemplate/html/layouts/joomla/content/intro_image.php (excerpt)
use Joomla\CMS\HTML\HTMLHelper;
$img = HTMLHelper::_('cleanImageURL', $images->image_intro);
$path = JPATH_ROOT . '/' . ltrim(parse_url($img->url, PHP_URL_PATH), '/');
?>
<figure class="<?php echo $this->escape($figureClass); ?> item-image">
<picture>
<?php foreach (['avif' => 'image/avif', 'webp' => 'image/webp'] as $ext => $type) : ?>
<?php if (is_file($path . '.' . $ext)) : ?>
<source srcset="/<?php /echo /$this->escape($img->url /. '.' /. /$ext); /?>" type="<?php echo $type; ?>">
<?php endif; ?>
<?php endforeach; ?>
<?php echo LayoutHelper::render('joomla.html.image', $layoutAttr); ?>
</picture>
</figure>
cleanImageURL matters. Joomla stores image fields as images/photo.jpg#joomlaImage://local-images/photo.jpg?width=1200&height=800, and the part after # must go before you build a file path. The <img> inside <picture> keeps its width, height and alt from Joomla's own image layout, so nothing else changes.
What it's worth
For photos, AVIF at similar visual quality is usually well under half the size of the JPEG, and WebP somewhere in between. On a blog list or a shop category page with a dozen images, that's the biggest single cut in page weight you can make without touching the design. Two things it doesn't fix:
- Oversized images. A 4000 px photo in a 600 px column is still too big in AVIF. Resize to the largest size the layout displays (×2 for high-density screens) first.
- A late LCP image. If the main image is lazy-loaded, a smaller file still starts late. See Joomla performance from the code up for the layout fix.
Checklist
- Media options:
webpandavifin the legal extensions and MIME types. gd_info()shows AVIF support, or editors know to resize before upload.- Existing images converted with the originals kept, named
file.jpg.avif/file.jpg.webp. - Served via
try_files+Vary: Accept, or via<picture>overrides. - The conversion runs again for new uploads (cron, or a step in your editors' workflow).
Heavy images slowing your Joomla site? We convert the library, set up serving and the overrides, and measure the result before and after.
SEO & speed optimization →
Most Joomla sites we work on were built by someone else. Before we quote anything or change a line, we spend a few hours on one question: what is actually running here? Sites rarely match their documentation, when there is any. There are core files edited in place, overrides nobody remembers, cron jobs on a server nobody has logged into for years.
This is the audit we run when we take over a Joomla site. It's written so you can run it yourself, or use it to judge whoever runs it for you.
1. Access and a copy
Before anything else, make sure you can restore what you're about to touch:
- Hosting panel, SSH or SFTP, database access, DNS, the domain registrar, any CDN.
- A Super User account of your own. Don't share the previous developer's.
- A full backup you made, restored once on a staging host. A backup you have never restored is a hope, not a backup.
# terminal – a quick full copy if there is no backup tool yet
tar --exclude='./cache/*' --exclude='./administrator/cache/*' --exclude='./tmp/*' -czf ~/site-files-$(date +%F).tgz -C /var/www/example.com .
mysqldump --single-transaction --no-tablespaces -u USER -p DBNAME | gzip > ~/site-db-$(date +%F).sql.gz
2. Versions
# terminal
grep -E "MAJOR_VERSION|MINOR_VERSION|PATCH_VERSION" libraries/src/Version.php
php -v # CLI
# web PHP: System → System Information (they often differ)
mysql -V
Write down Joomla, PHP (web and CLI), the database server, and the web server. Anything end-of-life goes straight to the top of the report: Joomla 3 or 4, PHP below 8.2, MySQL 5.x.
3. Core files: modified or not?
This is the check that changes quotes most often. A previous developer "fixed" something by editing a core file. The next Joomla update silently overwrites the fix, or, worse, the edit is a backdoor. Compare the site against a clean package of the same version:
# terminal
mkdir /tmp/clean && cd /tmp/clean
curl -sLO https://github.com/joomla/joomla-cms/releases/download/6.2.0/Joomla_6.2.0-Stable-Full_Package.zip
unzip -q Joomla_6.2.0-Stable-Full_Package.zip
diff -rq /tmp/clean /var/www/example.com \
| grep -vE "Only in /var/www/example.com|/(cache|tmp|images|logs|administrator/logs)/|configuration.php" \
| grep -E "\.php differ|\.js differ"
Every line in that output needs an explanation. In order of how often we find them: a patched core file, an outdated file left by an incomplete update, and occasionally an injected backdoor.
Then look for PHP files where none belong:
# terminal
find images media tmp cache -type f -name '*.php' ! -name 'index.php' 2>/dev/null
4. Extensions: what is installed and what is used
# terminal – third-party extensions, versions and status
mysql -e "SELECT type, element, folder, enabled,
JSON_UNQUOTE(JSON_EXTRACT(manifest_cache, '$.version')) AS version,
JSON_UNQUOTE(JSON_EXTRACT(manifest_cache, '$.author')) AS author
FROM jos_extensions
WHERE JSON_UNQUOTE(JSON_EXTRACT(manifest_cache, '$.author')) NOT LIKE 'Joomla%'
ORDER BY enabled DESC, type, element;" mydb
For each one: is there a current version, is the vendor still around, is it actually used (a component with an empty table usually isn't), and does it have an update site, so updates can reach the site at all? Disabled extensions still have reachable files. They go on the remove list.
5. Template and overrides
Overrides are where a site's real behaviour lives, and the first thing to break on updates:
# terminal – every override in the site template(s)
find templates/*/html -type f -name '*.php' | sort
# which override is older than the core layout it replaces? (Joomla flags these in System → Templates too)
for f in $(find templates/yourtemplate/html -name '*.php'); do
rel=${f#templates/yourtemplate/html/}
for core in components/${rel%%/*}/tmpl/${rel#*/} modules/${rel%%/*}/tmpl/${rel#*/} layouts/${rel#layouts/}; do
[ -f "$core" ] && [ "$core" -nt "$f" ] && echo "older than core: $f"
done
done
File dates are only a hint: after a fresh deploy every file has the same date, and then Joomla's own "Changes found" notice in System → Templates is the reliable check. Also check for a child template. If the site edits a vendor template directly, the next template update wipes the changes. Moving them into a child template is often the first fix we make.
6. Scheduled work and cron
Things that happen without anyone clicking: newsletter queues, imports, feeds, backups, cleanup tasks.
# terminal
crontab -l; sudo crontab -l -u www-data 2>/dev/null
php cli/joomla.php scheduler:list
Check whether the Lazy Scheduler is on (Scheduled Tasks → Options). If it is, tasks run during visitors' page loads. Check which PHP binary each cron line uses, and whether the jobs actually succeed. A backup cron that has been failing for a year is a classic.
7. Users and access
# terminal – Super Users and when they last logged in
mysql -e "SELECT u.username, u.email, u.block, u.lastvisitDate
FROM jos_users u JOIN jos_user_usergroup_map m ON m.user_id = u.id
WHERE m.group_id = 8 ORDER BY u.lastvisitDate DESC;" mydb
Former agencies, freelancers and staff with Super User rights are on almost every site we audit. So are accounts without MFA, and API tokens for integrations nobody remembers. Each goes in the report with a recommendation: block, downgrade, or keep.
8. Configuration that hurts quietly
| Setting | What we look for |
|---|---|
| Error Reporting | "Maximum" or "Development" on live leaks paths and SQL |
| Debug System | must be off on live |
| Session handler and lifetime | database handler with a long lifetime: a huge #__session table |
| PHP mail() instead of authenticated SMTP: contact forms end up in spam | |
| Caching | off entirely, or Progressive with a cache folder in the gigabytes |
| Live site / force SSL | mixed http/https URLs in content and canonical tags |
| Log folder | inside the web root and readable |
9. The front end, briefly
Not a full SEO audit, just the things that reveal neglect: PHP notices in the HTML, mixed content, 404s for assets in the browser console, jQuery and three slider libraries loaded on every page, and a robots.txt still blocking /images/ from an old Joomla default.
The report
We sort findings into three groups and quote only the first one up front:
- Risk now: end-of-life versions, modified core files, unknown Super Users, failing backups.
- Cost later: abandoned extensions, overrides older than core, a vendor template edited in place.
- Improvements: performance, SEO, editor experience.
A site audited this way rarely holds big surprises in the project that follows. The surprises came out in week one, while they were still cheap.
Inherited a Joomla site? We run this audit on a copy of it and send you a written report: what's running, what's at risk, and what we'd fix first.
Maintenance & support →
Portfolios and reviews tell you whether a Joomla developer finishes projects. They don't tell you whether the site will still be easy to update in three years. That depends on how the developer builds: overrides or core edits, child template or edited vendor template, a plugin or a hack in index.php.
These are the questions we'd ask if we were hiring a Joomla developer ourselves, with the answers that show real experience. You don't need to be technical to use them. Listen for specifics.
1. "How will you change how an article or module looks?"
Good answer: with a template override in templates/<template>/html/, made through System → Templates, ideally in a child template, so a template update can't overwrite it. They should mention that Joomla flags overrides when the core layout changes in an update.
Red flag: "I'll edit the file in components/com_content/". The next Joomla update wipes that change, or it blocks updates altogether.
2. "What would you do if an extension doesn't do exactly what we need?"
Good answer: it depends on the extension. First check its settings and its own extension points. Then a template override for its output, or a small plugin that listens to its events. Editing the vendor's code only as a last resort, in a documented patch that is re-applied on update.
A developer who reaches for a plugin knows that Joomla is event-driven. That is the single best sign of real Joomla experience, as opposed to general PHP experience.
3. "Which Joomla and PHP versions will the site run on, and why?"
Good answer, in 2026: Joomla 6.x on PHP 8.3 or 8.4 for a new site. Joomla 5.4 only if a required extension isn't ready for 6, with a plan to move before 5.4's support ends in October 2027. They should know that Joomla 6 needs PHP 8.3 and that old J* class names are off by default.
Red flag: not knowing the current version, or proposing Joomla 4 because "the template is for 4".
4. "How do you deploy changes to the live site?"
Good answer: code in Git; changes made and tested on a staging copy; deployed to live in a controlled way; a backup before every deploy. They can explain how database changes (new menu items, module settings) get to live, which is the hard part with Joomla, because much of a site's configuration lives in the database.
Red flag: "I work directly on the live site, it's faster."
5. "How do you keep the site secure after launch?"
Listen for specifics, not "we use a security extension":
- updates on a schedule, with security releases applied the same week;
- MFA enforced for administrators (Joomla has it in core since 4.2);
- off-site backups that are restored as a test now and then;
- no PHP execution in upload folders, and the admin area protected at the server level;
- a clean list of who has Super User access.
Our full list is in Joomla security against automated attacks.
6. "Show me code you wrote for Joomla."
Ask for a module, plugin or component from a recent project, or a public repository. Even without reading PHP, you can check a few things:
- a
src/folder with namespaced classes and aservices/provider.php: current Joomla structure since Joomla 4; use Joomla\CMS\…at the top of files, notJFactory::orJText::, which no longer load by default on Joomla 6;- language strings in
.inifiles, not English text in the PHP; - an update server in the manifest, so the extension can be updated from the back end.
// what modern Joomla code looks like – plugins/system/example/src/Extension/Example.php
namespace Example\Plugin\System\Example\Extension;
use Joomla\CMS\Event\Application\AfterRouteEvent;
use Joomla\CMS\Plugin\CMSPlugin;
use Joomla\Event\SubscriberInterface;
final class Example extends CMSPlugin implements SubscriberInterface
{
public static function getSubscribedEvents(): array
{
return ['onAfterRoute' => 'onAfterRoute'];
}
public function onAfterRoute(AfterRouteEvent $event): void
{
// …
}
}
7. "How do you estimate an upgrade or a takeover?"
Good answer: they look before they quote. A short paid audit, or at least a look at the extension list, the template and the overrides, and a check for modified core files, then a fixed quote with clear assumptions. Anyone who gives a fixed price for a Joomla 3 → 6 migration without seeing the site is guessing, and you'll pay for the guess one way or another. We describe our own takeover audit in taking over a Joomla site.
8. "What happens to the site if we stop working together?"
Good answer: you own everything: the code (in a repository you can access), the hosting and domain accounts, the extension licences, and a short document on how the site is built. No custom extension you can't update without them.
Freelancer, agency or in-house?
| Works well for | Watch out for | |
|---|---|---|
| Freelancer | small sites, clear scope, a direct line to the person who builds | holidays and illness; ask who covers urgent fixes |
| Joomla-focused team | upgrades, custom extensions, shops, long-term maintenance | make sure you know who actually does the work |
| General web agency | projects where Joomla is a small part | Joomla may be one CMS among many, so ask questions 1–3 above |
| In-house | constant changes, many internal integrations | knowledge leaves with the person; insist on Git and documentation |
Looking for a Joomla developer? We've built on Joomla since its first version. Ask us the questions above. We're happy to answer them before you hire anyone.
Our Joomla services →Page 7 of 7


