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
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
