Load Testing in Production without Staging or Specs

How our AQA team built a safe test setup for a live contractor SaaS and measured its capacity on the real system, with real customers online.

About project

Solution

Load testing, Performance testing, Stress testing

Technologies

Apache JMeter, Groovy, Python, Playwright, Chromium, Chrome DevTools Protocol, PostgreSQL, Supabase, Paddle

Country

United States

Industry

Technology

Client

A US-based SaaS platform for roofing and exterior contractors that measures properties from satellite and Street View imagery and turns the measurements into estimates and inspection reports.

Project overview

We’ll make sure your app is ready for the real world.

    Before

    • Unknown concurrent capacity
    • Untested failure behavior
    • Unclear source of slowdowns
    • No API specification

    After

    • Capacity ceiling at 615 req/s
    • Throughput collapse mapped
    • API layer identified as bottleneck
    • 15 real requests replayed

    Project Duration

    2 weeks

    Team Composition

    1 AQA Lead

    Challenge

    The client runs a US-based SaaS platform for roofing and exterior contractors. Users search an address and measure a roof from satellite and Street View imagery, then turn those measurements into customer estimates and inspection reports. The product was preparing to go live and serve paying teams when the client asked TestFort a single question: how many people could the platform handle at the same time?

    Answering it was harder than the question suggested. The platform has no custom backend. The React frontend, hosted on Vercel, talks directly to Supabase for data, authentication and server-side functions, while Mapbox and Google Maps serve imagery straight to the browser. Every test would have to run against the production system that real customers were using, through a narrow test account, with no way to see the servers from the inside.

    No staging environment

    Production was the only environment available. Any load generated would share infrastructure with live customer traffic, so a careless test could slow the product down for real users. Each run needed a safe ceiling and a way to stop automatically if the system began failing.

    Sign-in limits that look like failures

    Supabase Auth limits how often one IP can sign in. A test that logged in every virtual user separately would hit those limits quickly and return errors that look exactly like an application failure. With access tokens expiring after an hour, longer runs also needed a way to stay signed in without logging in again.

    No performance targets

    There were no agreed response-time limits, concurrency goals or error budgets. With nothing to pass or fail against, the results had to be presented as measurements, and every conclusion had to be backed by data the client could check.

    No API specification

    The app had no Swagger or OpenAPI document. Most data access goes through Supabase’s auto-generated PostgREST API, alongside 15 Edge Functions. The client’s technical brief described this surface, but the requests the app actually sends had to be captured from a real browser session before a load plan could be built.

    Endpoints that could cost money or affect customers

    Large parts of the API were off-limits for load. Billing operations through Paddle, transactional email through Resend, and QuickBooks and GoHighLevel integrations could all create real charges, messages, or records. Map tiles and geocoding are billed per request, so even browser-side profiling carried a direct cost. The test scope had to separate safe reads from anything that wrote data or triggered a third party.

    Solutions

    TestFort assigned one senior AQA engineer, who worked on the project for about two weeks. The engineer’s first step was to reframe the client’s brief. Vercel only serves the app’s static bundle from a CDN, so the real load target was the Supabase project behind it. Work was split into two tracks: backend load testing in JMeter and browser-side profiling in Playwright.

    Load built from real traffic

    The JMeter plan replayed the 15 read requests captured from a real browser session, with the same filters and the same Row Level Security checks as in production. Testing stayed read-only at the client’s request.

    Safeguards for a live system

    A single shared sign-in avoided Supabase Auth rate limits, with automatic token refresh. Users joined gradually, and an abort guard stopped any run once more than 10% of requests failed. Billing, email and third-party integration endpoints were excluded from load.

    Stepped runs, approved one by one

    Load climbed from 10 to 100 users, then toward 1,000, with the client approving each increase. A final run used two load machines at once to rule out the test setup as the cause of any slowdown.

    Database evidence next to load results

    Read-only SQL against PostgreSQL’s statistics views returned query execution times, index usage and connection limits, so every load result could be checked against what the database itself recorded.

    Browser-side profiling

    A Playwright harness for .NET measured load time, interface blocking, and billed map requests on desktop, laptop, and emulated phone profiles. A built-in cap limited how many billed requests each run could make.

    Technologies

    The tech stack for this project was built around the platform itself: a protocol-level load tool replayed the app’s real API requests, a browser automation harness measured performance on throttled devices, and read-only database queries let the client check both against what the server recorded.

    • Apache JMeter
    • Groovy
    • Python
    • Supabase
    • Playwright
    • Chrome DevTools Protocol
    • PostgreSQL
    • Paddle

    Types of testing

    Load testing

    Ramping concurrent users step by step to measure throughput and find the capacity ceiling.

    Performance testing

    Profiling app startup, map loading, and UI blocking on throttled desktop and phone profiles.

    Stress testing

    Pushing load past the ceiling to observe how the system fails and when requests time out.

    Results

    Backend throughput grew almost linearly to a peak of 615 requests per second at about 200 simulated users, an estimated 1,200-3,000 real users at once. Past that point, the system collapsed. Throughput fell to 50 requests per second at 500 users, and median response time rose from 101 ms to 4.5 seconds. Database queries kept executing in under 1 ms, which places the most likely bottleneck in the API layer and its 15-connection pool on the smallest compute tier.

    In the browser, the emulated phone on a slow connection needed 21-24 seconds to show the first screen, and the first address search took 11.9 seconds against 0.6 for the next. A single page visit also sent 16 identical profile reads and 15 identical checklist reads. Cutting those repeats would raise capacity with no infrastructure changes. The client was satisfied with the capacity the platform showed and accepted the results without a retest, now with a clear picture of where the ceiling sits and what would raise it.

    615

    req/s peak backend throughput

    1,200-3,000

    simultaneous users supported

    <1 ms

    average database query execution

    2M+

    requests sent to production

    Is your product market-ready?

    Ensure top-tier performance with expert QA

      Alex Pavlyuk

      Delivery Director

      Thank you for your message!

      We’ll get back to you shortly!

      Still comparing QA vendors?

      Book a call with our senior QA lead. We ask the right questions and give a second opinion you can trust.

      Get your slot now.