Article featured on Indie Hackers.
What Is SpeedFactor?
This is the story of SpeedFactor — a speed and performance tracking SaaS I built from scratch using WordPress. At its core, the app measures a wide range of website metrics and presents them as clear, readable charts and graphs over time. It calculates CMS speed, host speed, and tracks several security and SEO indicators. It was designed to be the perfect companion tool for SEO agencies, freelancers, and web developers who need a bird’s-eye view of site health across multiple clients.
Update (2024): SpeedFactor no longer exists as a standalone SaaS. Its core functionality has been integrated into the Lighthouse plugin for WordPress, where it lives on as part of a broader, actively maintained toolset. The story below is a piece of history — how an idea went from a cold email automation script to a fully functional multi-user SaaS.
How Did I Get the Idea?
It all started with a fairly practical problem: I wanted to send several hundred cold emails to potential web development clients, showing them just how slow their websites were. To do that efficiently, I needed to automate the process — run Google Lighthouse against each URL, pull the data, and fire off a personalised email.
While there are plenty of ways to automate Google Lighthouse (Python, Node.js, headless Chrome scripts, and so on), none of them are particularly approachable for a marketing person, an SEO agency, or a solo freelancer. So I built a basic interface around the automation and connected it to SendGrid for email delivery and HubSpot for CRM — a pretty solid, stable setup.
But as I used it, I realised Google Lighthouse alone wasn’t telling the full story. I needed more metrics: security indicators, CMS-layer performance, server response data. That’s when SpeedFactor was born. Even in its early, fairly basic form, it included a security audit and an SEO evaluation of the homepage (which I called SEOFactor).
I hadn’t sent a single cold email yet — but the audits were running daily and storing all values. That gave me a new idea: show an evolution chart. If I ever landed a web development contract, I could demonstrate a before-and-after comparison, build a case study, and use the data to promote my services further. A genuine win-win. So I added the charts.
Why WordPress?
WordPress is part of my daily work as a full-stack developer, so it was the natural choice when I needed multi-user support. The plan called for three distinct roles: me as admin checking overall functionality, a marketing person monitoring email progress, and clients reviewing their own site metrics. WordPress handles all of that out of the box.
Rather than reinventing the wheel, I used a stripped-down version of WordPress — no emoji scripts, no oEmbeds, no unnecessary JavaScript frameworks, no bloat. I built SpeedFactor as a plugin-and-theme bundle running on top of this lean core. This kept the platform fast and the codebase focused.
WordPress also made it easy to plug in third-party APIs: SendGrid for email, HubSpot for CRM, and eventually Stripe and PayPal for billing. The plugin ecosystem meant I could move fast without writing everything from scratch.
How Does It Work?
SpeedFactor started as a Google Lighthouse wrapper, but Lighthouse eventually represented only around 30% of the total metrics collected. Over time, I layered in:
- Manual checks — inspecting specific page elements and configurations
- Server-side checks — response times, headers, and server environment signals
- A beacon feature — measuring and calculating the speed difference between the raw host and the CMS layer sitting on top of it
- Security checks — covering common vulnerabilities and misconfigurations
- Core Web Vitals — integrated as Google rolled them out as a ranking signal
Every morning, the system runs all audits automatically and stores the results. Users can access their audit history (with some metrics gated by pricing plan), giving them a timeline of their site’s performance. This is especially useful when making changes — adding tracking scripts, uploading images, deploying stylesheets — because the impact on performance is immediately visible in the charts.
It grew from a cold-email tool into a proper on-demand metrics platform.
Where Did It Go?
From a development standpoint, SpeedFactor reached feature completeness. It was a one-person SaaS, deliberately kept simple, maintained monthly with fresh eyes — refactoring, rewriting, and improving rather than endlessly adding features. At its peak, I was using it across roughly 100 sites hosted on various servers and networks, which gave me reliable, real-world signal about what worked and what didn’t.
I use other tools myself — Google PageSpeed Insights, GTmetrix — and SpeedFactor was always designed to complement those, not compete with them. It filled the gaps: multi-site tracking, historical data, the host-vs-CMS beacon comparison.
Today, SpeedFactor no longer runs as a standalone SaaS. Its functionality has been folded into the Lighthouse plugin for WordPress — a more sustainable home for the toolset, actively developed and available directly from within WordPress. If the ideas in this article interest you, that’s where to find them now.
Building a SaaS on top of WordPress is a legitimate, pragmatic choice — especially when you need multi-user support, a solid database layer, and a rich plugin ecosystem from day one. You don’t always need to build your own auth, billing, or user management from scratch.
Starting with a personal problem (automating tedious client outreach) led to a tool that became genuinely useful beyond its original purpose. The pivot from “cold email tool” to “performance monitoring dashboard” happened naturally by following the data.
And sometimes, the best place for a SaaS to end up is folded neatly into something bigger.
