"Is WordPress slower than Shopify?" and "is it the marketing tags?" come up in every rebuild discussion, usually answered from one memorable bad site. You can check them for your own niche: find out what a sample of sites is built with, audit their home pages, and compare. Collecting the data is quick. The real work is not over-reading it. Public pages and public data only.

Why this is harder than it looks

  • Hosting. WordPress on a busy shared host and on a tuned managed host are different products. Server response time (TTFB) can explain more than the CMS.
  • Images and video. A home page with a 3 MB hero image is slow on any platform.
  • Who builds on what. Platform and company size travel together. Large companies buy custom builds, more tags and better engineers at once, so a platform gap may be a budget gap.
  • Lab noise. Two Lighthouse runs of the same page can differ by a few points.
  • Small groups. Twelve sites split over five platforms gives you groups of two. A median of two sites is an anecdote.

So the honest output is a table of medians (not means, which one extreme site can drag) with the group size next to every number, and the likely confounders beside them. It is not a verdict.

Pick a sample you can defend

Choose one niche and a list of its sites that does not depend on speed: a trade association's member directory, every dental practice in one city, all exhibitors at an industry show. Avoid the first page of Google results; those sites already rank, and ranking is partly about page experience, so you would be filtering on the thing you measure.

Aim for 50 sites or more and expect some to drop out. Audit the home page only, so the page type is the same everywhere.

Collect the stack and the audits

Two open-source Apify Actors do the collection. Website Tech Stack Detector fetches each page over plain HTTP and matches it against 7,600+ technology fingerprints, returning technologies[] with name and categories. PageSpeed Insights Audit calls Google's official PageSpeed Insights API and returns the Lighthouse score, lab metrics, field data and, with includeAuditDetails, the top opportunities[].

Send the same list to both. Stack detector input (placeholder domains; DNS checks off, since only the page matters here):

{ "urls": ["https://dentist-one.example", "https://dentist-two.example", "https://dentist-three.example"], "detectViaDns": false } 

Audit input, mobile and performance only:

{ "urls": ["https://dentist-one.example", "https://dentist-two.example", "https://dentist-three.example"], "strategy": "mobile", "categories": ["performance"], "includeAuditDetails": true } 

Save the inputs as tech-input.json and psi-input.json and run both:

curl -X POST "https://api.apify.com/v2/acts/josh99smith~tech-stack-detector/run-sync-get-dataset-items?token=$APIFY_TOKEN" \ -H "Content-Type: application/json" -d @tech-input.json -o tech.json curl -X POST "https://api.apify.com/v2/acts/josh99smith~pagespeed-insights-audit/run-sync-get-dataset-items?token=$APIFY_TOKEN" \ -H "Content-Type: application/json" -d @psi-input.json -o psi-1.json 

Synchronous calls suit short runs; each audit takes Google 10 to 30 seconds, so for 50+ sites start the audit from the Console and download the dataset. Run it three times on different days (psi-1.json to psi-3.json) so each site gets a median rather than one noisy reading.

Join and group with a script

The script joins the datasets by domain (www. removed), takes each site's median over repeated audits, and prints grouped medians with n per group. Platform is the first name from a fixed list found in the stack. The tag count is detected technologies in marketing and tracking categories. Two confounder columns sit beside the speed numbers: img ms, the estimated savings from image audits, and TTFB, the field 75th percentile where Google has page-level data. Save it as compare.py; Python 3.8+, no packages.

import json import sys from collections import defaultdict from statistics import median from urllib.parse import urlsplit # First match wins, so a Shopify store with a headless CMS counts as Shopify. PLATFORMS = ["Shopify", "Wix", "Squarespace", "Webflow", "WordPress", "Drupal", "Joomla", "Magento"] TAG_CATEGORIES = { "Analytics", "Advertising", "Tag managers", "Marketing automation", "Live chat", "A/B Testing", "Retargeting", "Personalisation", "Cookie compliance", "Widgets", "RUM", "Surveys", "Customer data platform", "Reviews", "Affiliate programs", "Segmentation", } IMAGE_AUDITS = {"image-delivery-insight", "uses-optimized-images", "modern-image-formats", "uses-responsive-images", "offscreen-images"} def domain(url): host = urlsplit(url if "//" in url else "https://" + url).hostname or "" return host[4:] if host.startswith("www.") else host def load(path): return json.load(open(path, encoding="utf-8")) def site_median(records, get): # one value per site: the median of its repeated audits values = [v for r in records if (v := get(r)) is not None] return median(values) if values else None def page_field(r, metric): # page-level field data only; origin-level numbers are skipped fd = r.get("fieldData") or {} return None if fd.get("originFallback") else (fd.get(metric) or {}).get("percentile") tech = {domain(r["url"]): r for r in load(sys.argv[1])} audits, audit_errors = defaultdict(list), {} for path in sys.argv[2:]: # pass several audit files if you repeated the run for r in load(path): if r["success"]: audits[domain(r["url"])].append(r) else: audit_errors[domain(r["url"])] = r["errorType"] rows, domains = [], sorted(set(tech) | set(audits) | set(audit_errors)) for d in domains: t, a = tech.get(d), audits.get(d) if not (t and t["success"]): print(f"skipped {d}: no stack ({t['errorType'] if t else 'not in tech file'})") continue if not a: print(f"skipped {d}: no audit ({audit_errors.get(d, 'not in audit file')})") continue names = set(t["technologyNames"]) rows.append({ "platform": next((n for n in PLATFORMS if n in names), "other/custom"), "tags": sum(1 for x in t["technologies"] if TAG_CATEGORIES & set(x["categories"])), "perf": site_median(a, lambda r: r["scores"]["performance"]), "lcp": site_median(a, lambda r: r["labMetrics"]["lcpMs"]), "tbt": site_median(a, lambda r: r["labMetrics"]["tbtMs"]), "img": site_median(a, lambda r: sum(o["savingsMs"] or 0 for o in r.get("opportunities", []) if o["id"] in IMAGE_AUDITS)), "ttfb": site_median(a, lambda r: page_field(r, "ttfbMs")), }) print(f"\njoined {len(rows)} of {len(domains)} domains\n") def table(title, key): groups = defaultdict(list) for r in rows: groups[key(r)].append(r) print(f"{title:14} {'n':>3} {'perf':>5} {'LCP ms':>8} {'TBT ms':>7} {'img ms':>7} {'TTFB ms (n)':>12}") for g, rs in sorted(groups.items(), key=lambda kv: -len(kv[1])): def med(k): v = [r[k] for r in rs if r[k] is not None] return f"{median(v):.0f}" if v else "n/a" ttfb_n = sum(r["ttfb"] is not None for r in rs) flag = " <- n<5, anecdote" if len(rs) < 5 else "" print(f"{g:14} {len(rs):>3} {med('perf'):>5} {med('lcp'):>8} {med('tbt'):>7} {med('img'):>7} " f"{med('ttfb') + f' ({ttfb_n})':>12}{flag}") print() table("platform", lambda r: r["platform"]) table("third-party", lambda r: "0-1 tags" if r["tags"] <= 1 else "2-3 tags" if r["tags"] <= 3 else "4+ tags") 

Run python compare.py tech.json psi-1.json psi-2.json psi-3.json.

Read the result

Below is trimmed output from a 14-site test sample with one audit each. It is illustrative output from sample data, not a finding: the sample was mostly the platforms' own marketing sites, which say nothing about sites built on them, and skipped domains are replaced with placeholders.

skipped site-a.example: no stack (blocked) skipped site-b.example: no stack (blocked) skipped site-c.example: no stack (blocked) joined 11 of 14 domains platform n perf LCP ms TBT ms img ms TTFB ms (n) WordPress 4 64 14371 218 1575 848 (4) <- n<5, anecdote other/custom 3 78 2275 322 0 349 (3) <- n<5, anecdote Shopify 1 47 18641 649 0 1187 (1) <- n<5, anecdote ... third-party n perf LCP ms TBT ms img ms TTFB ms (n) 0-1 tags 8 67 11476 280 0 731 (8) 2-3 tags 3 31 14131 2032 0 1162 (3) <- n<5, anecdote 

How to read a table like this:

  • Check the join line first. Three of fourteen sites dropped out because they returned 403 to the detector. If blocking is more common on some platforms, the dropouts bias the groups. Report them.
  • Ignore any group under five or so. The script flags them. With one Shopify site, "Shopify: 47" is a fact about one site, not a platform.
  • Compare TTFB and image savings across groups before blaming the platform. If the slow group also has double the TTFB, you may be looking at hosting.
  • The tag count is a floor. Detection reads the served HTML, so tags loaded later through Google Tag Manager are invisible and GTM counts as one. In this sample no site reached four detected tags. Read the third-party split as "visible tags", not total scripts.
  • A gap is a correlation, not a cause. The 2-3 tag group scores far lower here, but those are three large media and SaaS sites with slower TTFB too, and their tags may be a symptom of the same budget rather than the cause. To test a cause, change one thing: remove tags on a staging copy of one page and audit it again.

Cost and limits

The stack detector charges $0.008 per successfully analysed site; the audit Actor charges $0.004 per successful audit (one URL on one strategy). For 60 sites: 60 x $0.008 = $0.48 for stacks, and three mobile audit runs are 180 x $0.004 = $0.72, so $1.20 in total. If eight sites are blocked by the detector you pay for 52, $0.416. Failed sites cost nothing on either Actor and come back with an errorType, and each run stops at the maximum cost you set.

Limits to plan around:

  • Detection is HTTP-only, so client-side-only technologies are missed, and only the URL you give is analysed. Some sites return 403 to scripts; enabling Apify Proxy can help, and proxy traffic is billed separately by Apify.
  • Fingerprints can misfire when a page merely mentions a platform. Turn on includeEvidence and check a few records by hand.
  • The audit Actor uses a shared Google API key by default; when the quota runs out you get free rate-limited records. Pass your own free key as apiKey for a dedicated 25,000 audits a day.
  • Lab scores come from one simulated mobile device. Field data exists only for pages with enough Chrome traffic, so expect n/a on small sites.

If this saves you time, a review on the Store page helps other people find it, and a star on GitHub helps too.

Disclosure: I built both Actors. Source: github.com/josh99smith/tech-stack-detector and github.com/josh99smith/pagespeed-insights-audit. PageSpeed Insights and Lighthouse are Google trademarks, and WordPress, Shopify, Wix, Squarespace and Webflow belong to their owners; the Actors are not affiliated with any of them.