Expert Joomla guides
Tutorials, upgrade notes and AI workflows for people who build and run Joomla sites.
CiviCRM's public pages – contribution pages, event registration, profiles, mailing-list sign-ups – reach visitors through Joomla. After a Joomla upgrade or a site rebuild, it is common for some of them to stop working while the CiviCRM back end looks fine. Here is how to find and fix them.
How CiviCRM pages reach the front end
There are two ways a visitor lands on a CiviCRM page in Joomla:
- A Joomla menu item of a CiviCRM type: Contribution Page, Event Information Page, Event Registration Form, Event Listing, Mailing List Subscription, Profile forms, CiviCRM Dashboard and others. The menu item stores which page it shows (for example, the contribution page ID).
- A direct component URL with a CiviCRM path in the
taskparameter, for example:
These are in old emails, receipts, social posts and other sites linking to you./index.php?option=com_civicrm&task=civicrm/contribute/transact&reset=1&id=1
Both can break in an upgrade for different reasons.
Check 1: The menu items still exist and are valid
- Open Menus » All Menu Items and filter by the CiviCRM component. Every item should show a CiviCRM type, not "Menu item type unknown".
- Open each one and check Basic Options still points at the right page (contribution page, event, profile).
- Check access levels: the CiviCRM Dashboard should be Registered, public forms Public.
- Check the menu item is published and assigned to the right language.
If a CiviCRM menu item type is missing entirely, the component may not have installed cleanly – reinstall the same CiviCRM version over itself and check again.
Check 2: The CiviCRM page itself is active
A contribution page or event that was disabled, ended, or reached its registration limit shows an error or redirect, which can look like a broken page. In CiviCRM, open the page's settings and check it is active and within its dates.
Check 3: SEF URLs and aliases
- If you changed menu aliases or moved items between menus, the friendly URL changes. Links in emails and on other sites still use the old one.
- Joomla's Redirects component (enable the "System - Redirect" plugin with "Collect URLs" on) shows which old URLs visitors are hitting. Add a redirect for each.
- Long
task=civicrm/…URLs should keep working as long as the component is installed and the CiviCRM page exists. If they 404 too, the problem is the component or the page, not the alias.
Check 4: Old links in emails and receipts
Receipts and mailings sent years ago still carry links. Test a few real ones from your sent items: renewal links, event "register" links, unsubscribe and opt-out links. Unsubscribe and opt-out links are the ones you must not break – they come from CiviMail and need the component working, not a menu item.
Check 5: The template
A new template may lack an override CiviCRM's front-end pages rely on, or hide the component area on certain pages. If the CiviCRM form loads but appears empty or unstyled, test the same page with Joomla's default template (Cassiopeia). If it works there, the template is the cause.
Prevent it next time
- Before an upgrade, export a list of every CiviCRM menu item with its target page.
- Keep aliases unchanged during the upgrade; redesign URLs separately, with redirects.
- Add every public CiviCRM page to your post-upgrade test list – our test checklist has them all.
List every CiviCRM menu item from SQL
Before and after an upgrade, export the CiviCRM menu items with the page each one points to. Then a broken one is a diff, not a hunt:
# terminal – Joomla database, adjust the prefix
mysql -e "SELECT id, menutype, published, path, link
FROM jos_menu
WHERE link LIKE 'index.php?option=com_civicrm%' AND client_id = 0
ORDER BY menutype, lft;" joomla_db
The link column carries the CiviCRM route (task=civicrm/contribute/transact, civicrm/event/register, civicrm/profile/create …) and the page id, so you can check each one against CiviCRM: is contribution page 3 still active, does event 12 still exist?
For old links that must keep working, test them as a visitor would, without a session:
# terminal – status code of each old link (one URL per line in old-links.txt)
while read -r url; do
printf '%s %s
' "$(curl -s -o /dev/null -w '%{http_code}' -L "$url")" "$url"
done < old-links.txt
We keep the links that are already out there. On every CiviCRM upgrade we check menu items, old task URLs and add redirects where needed.
CiviCRM Joomla 6 upgrade →
This is step 1 of the route to Joomla 6: get an old shop onto Joomla 5.4 and VirtueMart 4.8, which are supported and patched. Do it on a staging copy; the live shop keeps selling until you switch.
Before you start
- A staging server with PHP 8.1–8.3 and MySQL 8.0.13+ or MariaDB 10.4+ (Joomla 5's requirements; PHP 8.3 also gets you ready for Joomla 6).
- A full backup of files and database, restored on staging.
- The VirtueMart 4.8 package from virtuemart.net. Some VirtueMart releases are offered to members first; check the download page.
- A list of your extensions, payment and shipping plugins, and overrides – see checking plugins.
Step 1: Make staging safe
- Put payment plugins in sandbox or test mode.
- Stop outgoing email (or catch it), so customers don't get order emails from staging.
- Block search engines from staging.
Step 2: Count your data
Write down how many products, categories, manufacturers, orders and shoppers the shop has. In phpMyAdmin or MySQL, with your table prefix:
SELECT COUNT(*) FROM jos_virtuemart_products;
SELECT COUNT(*) FROM jos_virtuemart_categories;
SELECT COUNT(*) FROM jos_virtuemart_orders;
SELECT COUNT(*) FROM jos_virtuemart_vmusers;
You will run the same queries after each step. Matching numbers are the quickest proof that nothing went missing.
Step 3: Update VirtueMart while still on Joomla 3.10
- Make sure Joomla is on 3.10 (the last Joomla 3).
- Install the VirtueMart 4 package over VirtueMart 3 through the Joomla extension installer – component first, then the AIO package, as the VirtueMart download explains.
- Open VirtueMart in the admin. If it offers database updates or tools, run them.
- Compare the counts.
- Open the shop front end: categories, a product, add to cart.
VirtueMart 4 supports Joomla 3.10, 4 and 5, which is what makes this order work: VirtueMart first, Joomla second.
Step 4: Upgrade Joomla 3 → 4 → 5.4
- Run Joomla's pre-update check for Joomla 4 and deal with every extension it flags – update, replace or remove.
- Switch to a Joomla 4-compatible template (or its new version) before the upgrade, if your template has no Joomla 4 version.
- Upgrade to Joomla 4, then straight on to the latest 5.4.
- Update VirtueMart to the latest 4.8.x again if a newer one is out.
- Compare the counts.
Step 5: Fix the shop front end
- Cart and checkout overrides need the security token – otherwise "Invalid token" when updating the cart. The fix.
- Compare every other override with the new core layout. How.
- Update or replace payment and shipping plugins.
Step 6: Test orders
Place a test order with every payment method and every shipping method, as a guest and as a registered shopper. Check the order in the admin, the emails, the stock, and the status changes after payment. The full list: test-order checklist.
Step 7: Switch live
- Pick a quiet hour. Put the live shop in maintenance mode.
- New orders and customers since you built staging must come across – either repeat the upgrade on live, or copy the new rows into the upgraded database. Don't lose a single order.
- Switch, place one real order with a small amount, refund it.
- Check redirects for any URLs that changed. Keep your URLs.
Common errors
- White page after the Joomla upgrade – an extension without a Joomla 4/5 version. Disable it from the database or the extension manager and replace it.
- Product images missing – check the media paths in VirtueMart configuration; VirtueMart 4.4.6 added a tool that repairs images that lost their image property.
- Prices or taxes look wrong – check the calculation rules and shopper groups on a few products against the old shop.
For developers: compare everything, not four tables
The four counts above catch the big losses. To catch anything, count every VirtueMart table before and after each step and diff the two files:
# terminal – row counts of all VirtueMart tables (adjust database and prefix)
mysql -N -e "SELECT CONCAT('SELECT ''', table_name, ''', COUNT(*) FROM ', table_name, ' UNION ALL')
FROM information_schema.tables
WHERE table_schema = 'shop_db' AND table_name LIKE 'jos\_virtuemart\_%';" \
| sed '$ s/ UNION ALL$/;/' | mysql -N shop_db > counts-step3.txt
diff counts-step2.txt counts-step3.txt
Expected differences are new tables or columns that VirtueMart 4 adds. Anything that loses rows is a stop sign. During the Joomla 3 → 4 → 5 steps, the Joomla CLI is faster than the browser for big shops: php cli/joomla.php core:update after each version change (Joomla 4+), then maintenance:database.
Rather have it done for you? We upgrade VirtueMart shops on staging, compare data after every step and test real orders before go-live.
VirtueMart Joomla 6 upgrade →
A shop's product and category pages carry years of search rankings and inbound links. A Joomla or VirtueMart upgrade can change their URLs – a router change, a renamed menu item, a different slug setting – and those rankings quietly drain away. Here is how to keep them.
Why URLs change
- Router changes between Joomla versions and between VirtueMart versions.
- Menu items renamed, moved or recreated during the upgrade – VirtueMart URLs are built from them.
- Slug handling. VirtueMart added a hidden setting for product slugs that can change a URL when the product name changes.
- SEF extensions (sh404SEF, JoomSEF and others) dropped or replaced because they have no new version.
1. Map the URLs before you start
On the live shop, collect every product and category URL:
- Export them from your XML sitemap, or crawl the shop with a crawler tool.
- Add the URLs that matter most from Google Search Console (Pages and Links reports) and your analytics: top landing pages, pages with backlinks.
Save the list. It is your before-picture.
2. Compare on staging
After the upgrade on staging, request every URL from the list (a crawler can take a list as input) and sort the results:
- 200, same page – fine.
- 404 – the URL changed or the page is gone.
- Redirect to something unexpected – often the home page or a category; check each.
VirtueMart improved its 404 handling in late 2025 (parts of the router used a wrong fallback), so some old URLs that used to "work" by accident may now correctly return 404 – they still need a redirect.
3. Fix the cause where you can
Before adding redirects, try to keep the original URLs: restore the menu item aliases, the category structure in menus, and the SEF settings the old shop used. Every URL kept as-is is better than a redirect.
4. Redirect the rest with 301s
- Use Joomla's Redirects component, or server rules (
.htaccess/ nginx) for large or patterned changes. - Redirect each old URL to its own new page – product to product, category to category. Redirecting everything to the home page is treated like a 404 by search engines.
- Redirect in one hop; avoid chains.
5. After go-live
- Turn on the "System – Redirect" plugin with URL collection for a few weeks and redirect the 404s it records.
- Submit the new sitemap in Search Console and watch the Pages report.
- Check feeds for Google Shopping or comparison sites – they carry product URLs too.
For developers: the settings that shape the URLs
VirtueMart's SEF output depends on a few configuration values (Configuration → SEO). Note them on the old shop and set the same on the new one before comparing anything:
| Setting (config key) | Effect on URLs |
|---|---|
seo_disabled | VirtueMart's own SEF router on or off |
seo_full | with 0, categories are left out of product URLs |
seo_use_id | IDs in the URL instead of slugs only |
seo_translate | translated URL segments ("detail", "manufacturer"…) |
Then the comparison itself is a loop over the old URL list:
# terminal – status and final URL of every old product/category URL against staging
sed 's#https://shop.example.com#https://staging.example.com#' old-urls.txt | while read -r u; do
curl -s -o /dev/null -L -w '%{http_code} %{url_effective}
' "$u"
done | tee url-check.txt | awk '$1 != 200' | head -50
Redirects for large, patterned changes are best as server rules. For a few hundred one-off URLs, Joomla's Redirects component (table #__redirect_links, columns old_url, new_url, header = 301) can take them as a bulk import.
We keep or redirect every product and category URL when we upgrade a shop, so it keeps its rankings.
VirtueMart Joomla 6 upgrade →
CiviCRM does a lot of its work on a schedule: sending CiviMail mailings, membership reminders and status updates, processing bounces, recurring contribution jobs. None of that happens unless a server cron calls CiviCRM regularly. After a Joomla or PHP upgrade, this is one of the first things to break – quietly.
Symptoms
- Mailings stay "Scheduled" and never send.
- Membership statuses don't change, renewal reminders stop.
- System Status says cron is not running.
- The job log (Administer » System Settings » Scheduled Jobs → View Log) has no recent entries.
Step 1: Check the job works by hand
In Scheduled Jobs, pick a harmless job such as CiviCRM Update Check, set it to run "Always", and click Execute Now. If it fails here, the problem is inside CiviCRM (permissions, a broken extension), not cron. Fix that first.
Step 2: Run the same job from the command line
There are three common ways to run CiviCRM's cron on Joomla. Try them by hand, as the same system user the web server runs as (often www-data).
cv (recommended)
cv cron --cwd=/var/www/example.org
cv is CiviCRM's command-line tool; cv cron is the alias of its core:cron command. It runs the jobs with full admin rights for the default domain. If it works in your shell but not from cron, use absolute paths to PHP and cv:
/usr/bin/php8.3 /usr/local/bin/cv cron --cwd=/var/www/example.org
cli.php
/usr/bin/php8.3 /var/www/example.org/administrator/components/com_civicrm/civicrm/bin/cli.php \
-s example.org -u cronuser -p 'password' -e Job -a execute
Use a dedicated Joomla user with the CiviCRM permissions the jobs need. -s should be your real domain – CiviMail uses it to build absolute links.
HTTP (cron.php)
If you have no shell access, call the cron URL from a web cron service:
https://example.org/administrator/components/com_civicrm/civicrm/bin/cron.php
with name, pass and key (your site key, CIVICRM_SITE_KEY in civicrm.settings.php) sent as POST data rather than in the URL.
Step 3: The usual causes after an upgrade
Different PHP on the command line
The web server runs PHP 8.3, but php on the command line is still 8.1 – or lacks bcmath or intl. CiviCRM's docs call this out specifically. Check both:
php -v
php -m | grep -E 'bcmath|intl|mbstring|zip'
Then put the full path to the right PHP binary in the crontab.
The path moved
A new server, a new document root or a staging copy promoted to live – and the crontab still points at the old folder. Check the paths in the crontab line one by one.
The cron user changed
Running cron as a different system user than the web server can leave files in media/civicrm that the web server can't write, and vice versa. Run cron as the web server user:
sudo crontab -e -u www-data
Only one job is called
If the crontab calls a single job (for example process_mailing) instead of Job.execute, mailings go out but System Status still reports cron as not running, and other jobs never run.
Step 4: Stop runs from piling up
On one of our client sites, the host flagged heavy database load from CiviCRM's cron after an upgrade. A run took longer than the five-minute interval, the next run started on top of it, and so on. The fix is a lock and a hard time limit:
*/5 * * * * flock -n /tmp/civicrm-cron.lock timeout 600 /usr/bin/php8.3 /usr/local/bin/cv cron --cwd=/var/www/example.org --quiet
flock -nskips a run if the previous one is still going.timeout 600stops a run after ten minutes, so one stuck job can't hold the lock forever.
After a week, check the job log: if jobs regularly hit the limit, look at which one is slow (often a large mailing or a bounce mailbox with thousands of messages).
Step 5: Confirm it runs
- Wait for the next cron interval.
- Open the job log – the test job should have a fresh "Success" entry.
- Check System Status – the cron warning should be gone.
- Set the test job back to its normal frequency.
Read the job log from SQL
The Scheduled Jobs screen shows one job at a time. The table behind it, civicrm_job_log, shows the whole picture: which jobs ran, when, and what they said.
# terminal – last run per job, newest first (in the CiviCRM database)
mysql -e "SELECT j.name, MAX(l.run_time) AS last_run, j.is_active, j.run_frequency
FROM civicrm_job j LEFT JOIN civicrm_job_log l ON l.job_id = j.id
GROUP BY j.id ORDER BY last_run DESC;" civicrm_db
# what the last ten runs reported
mysql -e "SELECT run_time, name, LEFT(description, 120) FROM civicrm_job_log ORDER BY id DESC LIMIT 10;" civicrm_db
An active job whose last_run is days old is your problem job. A gap of exactly the same length for all jobs means cron itself stopped. The civicrm_job table also has last_run and last_run_end: a last_run without a matching end means a run started and never finished, which is exactly the overlapping-run case above.
System Status from the shell, so you can check it from the same cron user:
# terminal
cv api4 System.check --cwd=/var/www/example.org | grep -iE '"(title|severity)"'
Cron is one line we check on every CiviCRM upgrade. We test it on the new stack with a time limit, alongside payments and mailings.
CiviCRM Joomla 6 upgrade →
Template overrides are how most VirtueMart shops get their look: copies of VirtueMart's layouts in the template, edited to fit the design. They are also the part of a shop that ages worst. VirtueMart keeps improving its layouts – new fields, security tokens, fixes – and an override from years ago keeps none of it. After an upgrade, that is where things break.
1. Find every override
VirtueMart overrides live in the active template:
templates/your-template/html/com_virtuemart/ – views: category, productdetails, cart, user, orders …
templates/your-template/html/mod_virtuemart_*/ – VirtueMart modules
Check which template the shop really uses: the default site template style, but also templates assigned to menu items, and templates set per category in VirtueMart. A child template can have its own overrides too.
List the files. A typical shop has somewhere between five and thirty.
2. Find the original each one came from
Each override replaces a core file in the component:
components/com_virtuemart/views/<view>/tmpl/<layout>.php
components/com_virtuemart/sublayouts/<sublayout>.php
Get the core file from the version the override was based on (often unknown) and from the version you are upgrading to.
3. Compare
Use a diff tool – or git, if the template is in a repository – to compare the override with the new core file. You are looking for:
- Missing token fields in forms (cart, checkout, account, ratings). These cause "Invalid token" errors. Details.
- Missing fields or variables added in newer layouts – custom fields, prices, stock messages.
- Old function calls that changed or were removed – especially relevant for VirtueMart 5, where some helper functions became static.
- jQuery-only scripts – VirtueMart 5 is moving away from jQuery.
- Design changes – the part that is actually yours and must be kept.
4. Rebuild, don't patch
For each override that differs a lot from core: start from the new core file and re-apply only your design changes. Patching an old copy just carries old bugs forward.
For overrides that only change markup or classes, a careful merge is enough.
And ask the honest question for each one: is the override still needed? Many shops override layouts to change one detail that CSS or a VirtueMart setting can handle today. Every override you remove is one less to maintain.
5. Test with real flows
Overrides break in use, not on sight. After rebuilding, run the shop as a customer – browse, filter, add to cart from pages and modules, update the cart, check out with each payment method. Test-order checklist.
6. Keep them maintainable
- Keep the template in version control, with a note in each override saying which VirtueMart version it was based on.
- At every VirtueMart feature release, diff your overrides against the new core layouts.
- Prefer CSS and VirtueMart settings over overrides for small changes.
For developers: diff all overrides in one go
# terminal – in the site root: which overrides differ from the current core layout, and by how much
T=templates/your-template/html/com_virtuemart
for f in $(cd $T && find . -name '*.php'); do
view=$(dirname "$f" | cut -d/ -f2); file=$(basename "$f")
core=components/com_virtuemart/views/$view/tmpl/$file
[ -f "$core" ] || core=components/com_virtuemart/sublayouts/$file
[ -f "$core" ] || { echo "NO CORE $f"; continue; }
echo "$(diff -u "$core" "$T/$f" | grep -c '^[-+][^-+]') lines $f"
done | sort -rn
The biggest numbers are the rebuild candidates, and "NO CORE" means the layout no longer exists in this version (or was a custom addition). VirtueMart honours overrides only while useLayoutOverrides is on (Configuration → Templates, "Use current shop template overrides"). Switching it off for a minute is the fastest way to prove an override is the cause of a bug.
Overrides are a fixed part of our store audit: every file listed, compared with the new core and rebuilt where needed.
VirtueMart Joomla 6 upgrade →
CiviCRM core keeps up with PHP well. CiviCRM extensions – payment processors, reports, integrations, small helpers someone installed years ago – are maintained on their own schedules, and they are usually what breaks when PHP goes up. CiviCRM's own docs warn about exactly this. Here is how we audit them before an upgrade.
1. List what is installed
Go to Administer » System Settings » Extensions. For each enabled extension note:
- name and key (for example
org.civicrm.example) - installed version
- whether an update is offered
- what the site uses it for – ask the people who run the site, not just the admin screen
With shell access, cv ext:list -Li lists installed extensions with versions, which is quicker to paste into a spreadsheet.
Disabled extensions still sit on disk. Remove the ones nobody needs before the upgrade – less to check, less to break.
2. Check each one
For every enabled extension, find its page in the CiviCRM extensions directory or its code repository and look for:
- Supported CiviCRM versions in the release info – does it list your target version?
- Last release date. Nothing in two or three years on an extension with PHP code is a warning sign.
- Open issues mentioning PHP 8.2 or 8.3, "deprecated", or the CiviCRM version you are moving to.
Then sort the list into three groups:
| Group | What it means | Action |
|---|---|---|
| Compatible | Recent release supporting your targets | Update it on staging |
| Update needed | A newer version exists | Update first, then test its feature |
| Unclear or abandoned | No recent release, no word on PHP 8.3 | Test on staging; replace, patch or remove |
3. Test on staging with errors visible
On a staging copy running the target PHP version, turn on CiviCRM's debugging and keep an eye on the PHP error log. Then use each extension's feature – run the report, make a test payment through the processor, trigger the integration.
On PHP 8.x, look for:
- Fatal errors – the extension is not usable as is.
- "Deprecated" notices – fine today, but they become errors in a later PHP version. Note them for the next round.
- Silent failures – a payment that never records, a report that comes back empty. Only testing the actual feature catches these.
4. Decide what to do with the problem ones
- Is it still needed? Often the feature moved into CiviCRM core (SearchKit and FormBuilder replaced many old report and form extensions).
- Is there a maintained alternative? Especially for payment processors.
- Can it be patched? Small PHP 8 fixes are usually quick. Send the patch upstream, so you are not maintaining a private fork.
What a good audit looks like
On a typical site we review, most extensions are fine, a few need an update and one or two need a decision. That one-line summary – "12 installed, 10 compatible, 2 to update" – is what should go into the upgrade plan and the quote, before any work starts.
Part of the bigger picture in CiviCRM on Joomla 6: the complete guide.
Speed it up with static checks
Clicking through every feature is the only real test, but a static pass finds the obvious PHP 8 problems first, so the click-through is shorter:
# terminal – where extensions live, and their declared compatibility
cv ext:list -Li --cwd=/var/www/example.org
grep -h -A3 "<compatibility>" /path/to/civicrm/ext/*/info.xml | grep "<ver>"
# syntax check every extension with the target PHP binary
find /path/to/civicrm/ext -name '*.php' -print0 | xargs -0 -n1 php8.3 -l | grep -v '^No syntax errors'
# PHP 8.3 compatibility scan (PHP_CodeSniffer + PHPCompatibility)
composer global require squizlabs/php_codesniffer phpcompatibility/php-compatibility
phpcs -p --standard=PHPCompatibility --runtime-set testVersion 8.3- /path/to/civicrm/ext/org.example.someext
PHPCompatibility reports removed functions, changed signatures and deprecated syntax. It can't see behaviour that changed silently (string-to-number comparisons, for example), which is why the feature test still decides.
Want the audit done for you? Every CiviCRM upgrade review we do lists each extension with a verdict, before we quote.
CiviCRM Joomla 6 upgrade →
A shop can lose its design and still take orders. It can't take orders without payment. Payment and shipping plugins are the part of a VirtueMart upgrade that deserves the most care – and the part most often left to the last day.
1. List what the shop really uses
In VirtueMart, open Shop » Payment Methods and Shop » Shipment Methods. For each published method, note:
- the plugin behind it (Joomla Extensions » Plugins, groups
vmpaymentandvmshipment), - its version and vendor,
- where its settings point: merchant account, API keys, IPN or webhook URLs.
Unpublished methods can be removed before the upgrade – less to check.
2. Check each one with its vendor
For every plugin, find out whether there is a version for:
- your target Joomla version (5.4 now; 6 later),
- your target VirtueMart version (4.8 now; 5 later),
- your target PHP version (8.3+ for Joomla 6).
Plugins bundled with VirtueMart's AIO package update with VirtueMart. Third-party gateways depend on their vendor. If the vendor is silent, treat it as "no".
3. Pay attention to security notices
VirtueMart 4.8.0 fixed a security issue in the Skrill payment plugin – the advice was to update or remove the plugin entirely. More in the 4.8.0 security release.
4. Decide: update, replace or drop
| Finding | Action |
|---|---|
| Vendor has a compatible version | Update on staging, re-check settings |
| Announced but not released | Plan the upgrade around it; don't go live without it |
| No version, vendor gone | Replace with a maintained gateway; tell customers if checkout changes |
| Method barely used | Drop it – check order history first |
5. Test with real transactions
- Use the gateway's sandbox on staging, with the staging URL registered for callbacks.
- Check that the order status changes after payment – this proves IPN/webhook callbacks reach the shop.
- Test refunds and cancelled payments if the plugin supports them.
- On live, after the switch, make one real small payment per method and refund it.
Callback URLs are the classic trap: they often point at the old site, an old path, or http:// instead of https://. Payments go through, but orders stay "pending".
6. Shipping: compare rates, not just "it works"
For shipping plugins, place test orders to a few typical destinations and weights and compare the rates with the old shop. A changed zone or tax setting won't throw an error – it will just charge the wrong amount.
Full test list: VirtueMart test-order checklist.
For developers: the inventory from SQL
Payment and shipment methods are rows in VirtueMart's own tables, each pointing at a Joomla plugin. One query gives the full picture, with plugin versions:
# terminal – published methods, their plugin and its version (adjust prefix)
mysql -e "SELECT 'payment' AS kind, m.virtuemart_paymentmethod_id AS id, m.payment_element AS plugin, m.published,
JSON_UNQUOTE(JSON_EXTRACT(e.manifest_cache, '$.version')) AS version, e.enabled AS plugin_enabled
FROM jos_virtuemart_paymentmethods m LEFT JOIN jos_extensions e ON e.extension_id = m.payment_jplugin_id
UNION ALL
SELECT 'shipment', s.virtuemart_shipmentmethod_id, s.shipment_element, s.published,
JSON_UNQUOTE(JSON_EXTRACT(e.manifest_cache, '$.version')), e.enabled
FROM jos_virtuemart_shipmentmethods s LEFT JOIN jos_extensions e ON e.extension_id = s.shipment_jplugin_id
ORDER BY kind, published DESC;" shop_db
Then check which methods were actually used recently. A published method nobody chose in a year is a candidate to drop:
# terminal – orders per payment method in the last 12 months
mysql -e "SELECT virtuemart_paymentmethod_id, COUNT(*) FROM jos_virtuemart_orders
WHERE created_on > NOW() - INTERVAL 12 MONTH GROUP BY 1 ORDER BY 2 DESC;" shop_db
For callbacks: request the notification URL from outside (curl -I https://shop.example.com/index.php?option=com_virtuemart&view=vmplg&task=notify… with the path your gateway uses). It should return 200 over HTTPS, not a redirect or a login page.
Every payment and shipping plugin gets a verdict in our store audit – update, replace or drop – before we quote.
VirtueMart Joomla 6 upgrade →
Most failed CiviCRM upgrades we see don't fail in CiviCRM. They fail on the server: a PHP extension that isn't there, a database too old for Joomla 6, a command-line PHP that differs from the web one. Fifteen minutes of checking saves a broken weekend.
The target
For CiviCRM 6.x on Joomla 6 you need what both ask for:
| Check | Minimum | Better |
|---|---|---|
| PHP (web and CLI) | 8.3 | 8.4 |
| MySQL | 8.0.13 | 8.4 |
| MariaDB (instead of MySQL) | 10.4 | 10.6+ / 11.4 |
| PHP memory limit | 256M | 512M |
| PHP extensions | bcmath, intl, zip, mbstring, gd, dom, simplexml, json, curl, mysqli/pdo_mysql | |
On Joomla 5.4, PHP 8.1+ and MySQL 8.0.13 / MariaDB 10.4 already apply; CiviCRM 6.16+ recommends PHP 8.3 or newer.
1. PHP on the web
In Joomla: System » System Information » PHP Information. Note the version and search the page for bcmath, intl, zip and mbstring. CiviCRM's own System Status screen also warns about missing extensions.
2. PHP on the command line
This is the one that gets missed. Cron and cv run on the command-line PHP, which can be a different version with different extensions:
php -v
php -m | grep -Ei 'bcmath|intl|zip|mbstring|mysqli|pdo_mysql'
php -i | grep -E 'memory_limit|max_execution_time'
If php is the wrong version, find the right binary (for example /usr/bin/php8.3 or, on cPanel, /opt/cpanel/ea-php83/root/usr/bin/php) and use its full path in cron.
3. The database
In Joomla: System Information » System Information shows the database version. Or from the shell:
mysql -V
mysql -u user -p -e "SELECT VERSION();"
MySQL 5.7 or MariaDB 10.3 means a database upgrade before Joomla 6 – on shared hosting, often a move to a newer plan or server. Ask the host early; it is the slowest part to arrange.
If CiviCRM uses its own database, check it lives on the same server version, and read about the separate-database upgrade bug.
4. Limits that matter during the upgrade
memory_limit– 256M at least; the CiviCRM installer and database upgrade are memory-hungry.max_execution_time– raise to 300–600 seconds for the upgrade itself.upload_max_filesize– only matters if you upload the package through the browser; unzipping intotmpand using Install from Folder avoids it.
5. Disk space and permissions
- Room for a full backup plus the unzipped CiviCRM package (several hundred MB).
- The web server user can write to
media/civicrmand the Joomlatmpfolder.
Write it down
Keep the results with your upgrade plan: PHP web/CLI versions, extensions, database version, limits, and who changes what (you or the host). If anything is below the minimum, fix the server first and upgrade second – never both on the same night.
Next: audit your CiviCRM extensions for PHP 8.3, then follow the upgrade walkthrough.
The whole check as one script
Run it as the user cron runs as, so you see the CLI PHP that matters:
# terminal – precheck.sh
#!/bin/sh
echo "PHP CLI: $(php -r 'echo PHP_VERSION;') ($(command -v php))"
for ext in bcmath intl zip mbstring gd dom simplexml json curl mysqli pdo_mysql; do
php -m | grep -qix "$ext" || echo "MISSING extension: $ext"
done
php -r 'printf("memory_limit=%s max_execution_time=%s
", ini_get("memory_limit"), ini_get("max_execution_time"));'
mysql -N -e "SELECT VERSION();"
df -h . | tail -1
# CiviCRM's own view of the environment (after install)
cv status --cwd=/var/www/example.org
Compare the CLI result with System → System Information in Joomla (the web PHP). Any difference between the two is a cron problem waiting to happen.
Not sure your hosting can take it? We include a server check in every CiviCRM upgrade review, and help move to a host that meets it.
CiviCRM Joomla 6 upgrade →
MCP doesn't replace Joomla's REST API. It sits on top of it. The real question for a developer is when a task should be a script that calls the API, and when it should be a tool an AI assistant calls. We use both every week. Here's how we decide.
Same API underneath
Script: cron / CI ──▶ your code ─────────────────────────────▶ Joomla /api/index.php/v1/…
MCP: person ──▶ Claude ──▶ MCP server (your tool code) ──▶ Joomla /api/index.php/v1/…
Both paths end at the same endpoints, with the same token and the same Joomla permissions. What differs is who decides which calls to make. With a script, you decide when you write it. With MCP, the model decides at runtime, within the tools you exposed.
When a script is the right tool
- The steps are known in advance. Import 500 products from a CSV, sync users from a CRM, publish scheduled content. A model adds nothing but cost and variance.
- It must be exactly the same every time. Scripts are deterministic and testable. A model may take a different path tomorrow.
- Volume. Thousands of calls cost nothing as a script and a lot as model tokens.
- Unattended runs. Cron at 3 a.m. doesn't need natural language.
# terminal – a typical script job: unpublish articles whose event date has passed
curl -s -G -H "Authorization: Bearer $TOKEN" -H "Accept: application/vnd.api+json" \
--data-urlencode "filter[category]=31" --data-urlencode "filter[state]=1" --data-urlencode "page[limit]=100" \
"https://example.com/api/index.php/v1/content/articles" \
| jq -r '.data[] | select(.attributes.event_date < (now | strftime("%Y-%m-%d"))) | .id' \
| while read id; do
curl -s -X PATCH -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
"https://example.com/api/index.php/v1/content/articles/$id" -d '{"state": 0}' >/dev/null
done
(event_date is a custom field. The API returns custom fields by name on items.)
When MCP is the right tool
- The question changes every time. "Which posts mention Joomla 4 but haven't been updated since 2024?" "Are there two articles competing for the same keyword?" Writing a script for each question costs more than asking.
- The work needs judgement on text. Drafting, rewriting a description, suggesting internal links, checking tone. That's what models are for.
- A person is in the loop anyway. Editors working with an assistant, where each write is a draft someone reviews.
Designing tools: fewer, narrower, safer
Exposing the whole REST API as MCP tools ("create", "update", "delete" for every resource) is the most common mistake. The model then has to plan multi-step operations with generic tools, and the riskiest operations are always one call away. Better tools are shaped like tasks:
| Generic (avoid) | Task-shaped (prefer) |
|---|---|
update_article(id, fields) | update_meta_description(id, text) with a 160-character limit in the schema |
create_article(fields) | create_draft(title, catid, html), which always saves unpublished |
delete_article(id) | no tool; trashing is a human action |
query(sql) | find_articles_without_meta(category) |
Constraints in the tool's input schema (max lengths, allowed categories, enums) are enforced before the API is called, whatever the model sends. Tool descriptions matter too. The model chooses tools by reading them, so "Creates an UNPUBLISHED draft for human review" is a safety feature, not documentation.
Errors: scripts fail, models improvise
A script that gets a 400 stops and logs it. A model that gets a 400 tries something else, which is helpful when it fixes a typo in an alias and harmful when it "works around" a permission error. Return errors to the model as plain, specific text ("Category 24 not allowed for this user"), and never design a tool where a retry with different arguments can widen what it does.
Cost and speed, roughly
| Script via API | Assistant via MCP | |
|---|---|---|
| Per call | milliseconds, free | seconds, model tokens per step |
| Building it | developer time per task | tools once, then questions are free-form |
| Repeatability | exact | similar, not identical |
| Best for | known, repeated, high-volume jobs | ad-hoc questions, text work, small batches with review |
The combination we use
Scripts (and Scheduler tasks) for everything repeatable. A small MCP server with read tools and draft-only writes for editors and for us. And a rule for the line between them: when we've asked the assistant the same question three times, it becomes a script or a report.
The code for both sides is in Joomla REST API for beginners and How to build a Joomla MCP server.
Automating content or data on Joomla? We help you decide what should be a script and what an AI tool, and build both on the Joomla API.
Back-end development →
We build on Joomla and we're obviously not neutral. So this comparison sticks to things you can check: what each CMS has in core, what needs a plugin, and what that means when an AI tool or an automation pipeline works with the site. Where WordPress is ahead, we say so.
The comparison
| Capability | Joomla 6 | WordPress |
|---|---|---|
| REST API in core | yes, since 4.0 (2021), JSON:API format | yes, since 4.7 (2016), WordPress's own JSON format |
| API authentication in core | per-user API tokens (Bearer) | application passwords (since 5.6), via Basic auth |
| Permissions | ACL per action, per category and per item, plus view levels | roles and capabilities, site-wide; per-category rules need plugins |
| Editorial workflow | configurable workflows with per-transition permissions, in core | draft / pending / published in core; custom workflows via plugins |
| Multilingual | core, with associations and hreflang | plugins (e.g. WPML, Polylang) |
| Structured data | schema.org plugins in core (since 5.0) | usually via an SEO plugin |
| Background jobs | Scheduler with task plugins; can run from real cron | WP-Cron, triggered by page visits unless replaced by real cron |
| CLI | cli/joomla.php in core | WP-CLI (separate project, very mature) |
| AI building blocks from the project | none in core yet | an AI team working on standard building blocks, including a way for plugins to expose "abilities" to AI tools and an MCP adapter |
| AI plugins available | a modest number | many more, in every category |
Where Joomla's core helps with AI work
Containment is built in
Letting an AI write to a CMS is mostly a permissions problem. In Joomla, the AI's account can be limited to "create drafts in these two categories, execute only the 'submit for review' transition", using core ACL and Workflows, enforced on every API request. In WordPress, a role like "Contributor" gets close, but restricting it to specific categories, or adding a review stage with its own permissions, means plugins. Each plugin is one more thing to trust and update.
One API style, documented by its routes
Joomla's API is JSON:API throughout: the same list/filter/paging conventions for articles, categories, users, menus and modules. For an AI tool or a generated client that's predictable. WordPress's API is more varied, partly because plugins add endpoints in their own style, but it's far more widely documented and used.
Multilingual and structured data without plugins
For AI translation pipelines, Joomla's core associations give a clear target: create the translated article as a draft, then associate it. Schema.org in core means AI-generated content gets structured data without another plugin in the chain.
Where WordPress is ahead
- Ecosystem. Far more AI plugins, integrations and tutorials. If you want an off-the-shelf AI feature today, WordPress probably has a plugin for it.
- Project-level AI work. The WordPress project has an AI team working on shared building blocks, so plugins can expose capabilities to AI tools in one standard way, including through MCP. Joomla has nothing comparable in core yet. Joomla integrations are built per site or per extension, on top of the API.
- Familiarity. More developers, and more AI-generated code that actually works, because models have seen far more WordPress code than Joomla code. In our experience, AI-written Joomla code needs more correction: older APIs, invented option names.
What this means in practice
- Content teams with review needs, multilingual sites, organisations with real permission structures: Joomla's core gives an AI integration a safer frame with fewer moving parts.
- Sites that want many ready-made AI features quickly: WordPress's ecosystem is hard to beat.
- Either way: the important parts are platform-independent. A dedicated user with minimal rights, drafts instead of publishing, model calls outside the page request, keys outside the database. Our Joomla versions of those are in Claude writes, Joomla publishes and where AI fits in Joomla's architecture.
Choosing a CMS for its AI story alone is a mistake. The AI tools change every few months, and the CMS stays for years. Choose for content model, permissions, languages and the team that will maintain it, then add AI on top through the API.
Weighing Joomla for a new project? Tell us what the site has to do. We'll tell you honestly whether Joomla is the right fit, and how AI would plug into it.
Let's talk →
A symptom that showed up after the VirtueMart 4.8.0 security release: "Add to cart" works on the product page but fails from a product module – latest products, featured, related – especially on sites with caching turned on. Here is what happened and how to fix it.
Why it happens
VirtueMart 4.8.0 added a token check to the "add to cart" form. A token belongs to one visitor's session. When a product module is cached, Joomla stores its HTML – including the token of whoever loaded it first – and shows that same HTML to everyone. For every other visitor the token is wrong, so the add-to-cart request is rejected.
VirtueMart's lead developer explained it in the 4.8.2 announcement: the token check for add-to-cart had no real attack scenario, but caching made it break real shops.
The fix: update to 4.8.2
VirtueMart 4.8.2 (31 August 2026) solves it properly: the add-to-cart script now adds the token itself, from VirtueMart's JavaScript object, at the moment of the click – so cached HTML no longer matters. It also widened the script's selector so it finds VirtueMart forms in more templates.
The same release reverted an accidental change to the parameters of a plugin function (onstoreplugintable) that broke some plugins, and tidied the display of custom form fields. Worth installing for those alone.
If you can't update yet
- Turn off caching for the affected product modules (module settings, Advanced » Caching » No caching).
- If you use a page cache (Joomla's System – Page Cache plugin or a host-level cache), exclude pages with add-to-cart buttons, or at least the cart.
Both cost some speed. Treat them as a bridge to 4.8.2, not a fix.
Check it works
- Update to 4.8.2 and clear all caches.
- In a private browser window (a fresh session), add a product to the cart from each product module.
- Repeat in a second private window – a different session – to be sure the cached HTML works for everyone.
- Turn caching back on if you turned it off, and repeat.
Seeing "Invalid token" when updating the cart instead? That is the template-override issue: five ways to fix it.
For developers: find what is cached
# terminal – VirtueMart modules with caching on (Joomla database, adjust prefix)
mysql -e "SELECT id, title, module, position,
JSON_UNQUOTE(JSON_EXTRACT(params, '$.cache')) AS cache,
JSON_UNQUOTE(JSON_EXTRACT(params, '$.cache_time')) AS cache_time
FROM jos_modules
WHERE module LIKE 'mod_virtuemart%' AND published = 1 AND client_id = 0;" shop_db
# is the page cache plugin on?
mysql -e "SELECT element, enabled FROM jos_extensions WHERE folder = 'system' AND element = 'cache';" shop_db
The general rule behind this bug applies to every extension: anything tied to a session (form tokens, cart counts, "Hello, name") must not be rendered into HTML that a cache can serve to someone else. Either the page part isn't cached, or the value is added in the browser at the moment it's needed, which is what 4.8.2 does. More on cache scope in Joomla performance from the code up.
Keeping VirtueMart current without surprises is part of every shop we look after – updates on staging first, then test orders.
VirtueMart Joomla 6 upgrade →
VirtueMart 4.8.2 is a small follow-up to the 4.8.0 security release. It is not a security release itself, but it fixes two problems 4.8.0 caused on real shops. If you are on 4.8.0 or 4.8.1, update.
What it fixes
Add to cart in cached modules
4.8.0 added a token to the add-to-cart form. In a cached product module, the token of one visitor was shown to everyone, so add-to-cart failed for other sessions. 4.8.2 lets the add-to-cart script add the token itself at click time, and widens the script's selector so it finds VirtueMart forms in more templates. Full explanation.
A plugin parameter change, reverted
The parameter list of the function onstoreplugintable had been extended by accident in the parent class, which caused problems with some plugins. 4.8.2 reverts it.
Cleaner custom form fields
The display of custom form fields was tidied up.
Our verdict
- On 4.8.0 or 4.8.1: update – especially with module or page caching.
- On an older 4.x: go straight to 4.8.2; it includes the 4.8.0 security fixes. What those change.
- Test: add to cart from every product module in two browser sessions, update the cart, one checkout per payment method.
VirtueMart 4.8.2 still runs on Joomla 3.10 to 5. Joomla 6 needs VirtueMart 5 – current status.
Check what's installed
# terminal – the VirtueMart version actually running
grep -E "static \$(RELEASE|REVISION)" administrator/components/com_virtuemart/version.php
mysql -N -e "SELECT JSON_UNQUOTE(JSON_EXTRACT(manifest_cache, '$.version')) FROM jos_extensions WHERE element = 'com_virtuemart';" shop_db
Both should say 4.8.2. If the manifest and version.php disagree, an update was interrupted: install the 4.8.2 package again over itself. Background on the cache issue this fixes, and how to find cached VirtueMart modules, is in Add to cart fails with cached product modules.
We follow every VirtueMart release and note what it means for Joomla shops. The latest is on our service page.
See Release watch →Page 4 of 7


