Auditor: Automating Accessibility, SEO, and Performance Checks

Context and Why Auditor Exists

Over the past few years, I've spent countless hours toggling between tools like Lighthouse, axe-core, and manual checks across dozens (sometimes hundreds) of client URLs. Each project required repeating the same process: copy a link, run the audit, wait for results, save a screenshot, export a report, and stitch it all together into something usable. It worked, but it was painfully slow.

The friction wasn’t just time — it was visibility. Clients often only saw a PDF or a spreadsheet, detached from the actual experience of their website. And internally, I found it harder than it should have been to track which checks had already been run, what was pending, and where the critical issues were.

Auditor was built to change that. It’s not a “product” in the commercial sense (at least not yet). It’s a workflow utility — part of the toolkit I’m building for myself and my projects. Its job is to take the grunt work out of running site-wide audits and give me (and the people I collaborate with) a clear, interactive view of what’s happening.

What Auditor Actually Does

Auditor is a batch scanning utility for websites. At its core, it takes in a list of URLs (manually entered, pasted in, or uploaded via CSV), spins up an automated job, and produces a structured set of results.

Here’s what those results include:

• HTTP health – status codes, HTTPS presence, redirects, and whether the page is actually reachable.
• SEO basics – titles, meta descriptions, canonical tags, sitemap checks, and indexability.
• Accessibility (a11y) – powered by axe-core, capturing violations across WCAG levels and Section 508.
• Performance metrics – PageSpeed Insights (PSI) scores, including LCP, CLS, INP.
• Artifacts and visual context – annotated screenshots that overlay detected issues directly on the page.

The workflow is simple:

1. Select an agency (org) and project (site).
2. Add or import URLs.
3. Run the scan.
4. Review results in a sortable, filterable table.
5. Dive deeper into interactive viewers for specific accessibility issues.

Everything persists in the background. Jobs, sites, and orgs are saved into a database. Each run has an ID, can be resumed, and results can be exported to CSV for clients or colleagues who still want spreadsheets.

Technical Foundations

Under the hood, Auditor is built on Next.js (App Router) with a mix of serverless and Node.js runtime APIs:

• Job system – Each run creates a job (/api/run), persists metadata in a .data/jobs store, and tracks progress (queued → running → done).
• Execution – URLs are processed concurrently (configurable), each audited with accessibility, SEO, and performance checks.
• Artifacts – Screenshots are captured and annotated with bounding boxes where accessibility issues occur. These are then made viewable in-browser.
• Results APIs – JSON and CSV endpoints (/api/results/[jobId]) make it easy to integrate with other systems.
• Frontend components – Results tables, progress bars, and summary cards give an at-a-glance view of what matters.

One of the most powerful pieces is the interactive viewer. Instead of staring at a raw report, you can actually see a screenshot of the page with overlays marking where accessibility violations exist. Issues are color-coded by severity, clickable, and linked to WCAG/508 documentation for guidance.

Why It Matters

Auditor isn’t meant to replace human judgment — it’s about scale and visibility. Here’s why it’s important:

• Efficiency: Running 100+ URLs manually is a slog. Auditor handles them in parallel and gives a consolidated summary.
• Consistency: Every URL is measured the same way. No missed checks, no human error.
• Transparency: Clients don’t just get a spreadsheet — they get annotated evidence tied to their actual site.
• Iteration: Because results persist, I can re-run jobs after fixes and immediately compare outcomes.

This matters in real client work. When deadlines are tight and deliverables need to be clear, Auditor ensures nothing slips through the cracks.

Auditor in My Workflow

I use Auditor in three main contexts:

1. Pre-engagement reviews – Quick scans of a prospective client’s site to identify opportunities and show concrete value before we start.
2. Active project QA – Mid-sprint checks to validate that accessibility and SEO requirements aren’t being broken as features ship.
3. End-of-project handoff – Final scans that produce a clean report for clients, often forming part of the documentation package.

It also fits into my larger toolkit. Jobs can be linked to my other systems (like Ultima for orchestration or Ship for project tracking). It becomes another utility in the Strong Start ecosystem — not a standalone SaaS, but a piece of the puzzle that keeps everything moving.

Challenges and Learnings

Building Auditor taught me a few things:

• Screenshots and annotations are harder than they look. Mapping rects onto screenshots, clipping them to image bounds, and keeping everything performant in the browser was a whole project in itself.
• Batch jobs need careful persistence. Crashes or restarts shouldn’t lose state. That’s why Auditor uses both in-memory and file-backed storage, plus DB headers for history.
• Users want CSVs, but they need visuals. Spreadsheets are still essential for some workflows, but once people see annotated screenshots, they rarely go back.
• Concurrency tuning is delicate. Too high, and external APIs (like PSI) throttle you. Too low, and scans take forever.

These lessons will shape how Auditor evolves.

The Future of Auditor

Right now, Auditor is alpha — it works, but it’s still being battle-tested. My roadmap includes:

• CI integration: Run Auditor as part of deploy pipelines for ongoing QA.
• Diffing results: Compare jobs across runs to highlight regressions or improvements.
• Multi-tenant support: Agencies can manage multiple clients cleanly (already partially supported with orgs/sites).
• Better exports: Polished PDF reports with summaries and visuals.
• Deeper metrics: Beyond SEO basics, include structured data validation, Core Web Vitals distribution, and analytics checks.

The long-term vision is a single command or button press to audit entire digital properties with clarity, repeatability, and transparency.

Closing Thoughts

Auditor is one of those projects that started as “I need this for myself” and quickly became “I can’t work without it.” It has already saved me hours of repetitive effort and given clients a clearer window into their websites.

It’s not flashy. It’s not a SaaS with a marketing site. It’s a utility — but it’s exactly the kind of utility that makes everything else faster, clearer, and more accountable.

And that’s what I want my Labs projects to be: not just experiments, but real tools that earn their keep in the workflow.