Skip to content

Checklist

Web app performance and scalability checklist

Will our product hold up when usage grows?

About engineering retainers
Checks
43
Sections
7
Last updated

Pixelact's web app performance and scalability checklist is 43 yes-or-no checks that show whether a SaaS product will hold up when usage grows. It covers database queries and indexes, caching and background jobs, frontend speed and Core Web Vitals, infrastructure limits, load testing, observability, and cost. Each check names the risk it prevents.

It is a SaaS performance checklist for founders, CTOs, and engineering leads at seed and Series A startups with a live product. Run it before usage jumps, not after the first outage:

  • Before a launch, a press moment, or a sales push that could multiply traffic.
  • Before a customer several times larger than your current biggest one goes live.
  • When pages, reports, or exports have slowed down as accounts grew.
  • After a fast first build where speed rightly came first. If AI coding tools wrote much of the code, pair this with the AI-built app risk checklist.

Answer yes only when you can point to evidence, such as a query plan, a dashboard, or a load test report. Unsure counts as no. A check that doesn't apply, such as job retries in an app with no job queue, drops out of the count.

Section 010 of 7 checked

Do database queries and indexes keep up as data grows?

  • This pattern, called an N+1 query, runs 21 queries for a page of 20 rows and 2,001 for an unpaginated list of 2,000. It feels fast in development and times out for your largest accounts first.
  • An unbounded query returns every row an account has ever created, so response size, memory, and query time all grow with the customer. A server-side cap stops a missing parameter from loading 100,000 rows into memory.
  • Postgres indexes primary keys and unique constraints automatically, but the Postgres documentation on constraints notes that a foreign key does not index the referencing columns. Queries that fetch child rows by parent, such as every invoice for one account, then scan the whole child table, and so does each delete on the parent table.
  • In a shared-schema SaaS app, a query that filters by tenant and date but can only use an index on date reads every customer's rows in that range. An index led by the tenant column keeps each query proportional to one customer's data.
  • The query plan shows whether Postgres uses an index or scans the full table. On a small development database, Postgres often picks a full scan because it is cheaper at that size, so only real row counts show the plan your customers get.
  • Ranking by total_exec_time instead of the slowest single call finds the 20 ms query that runs 50,000 times an hour, about 17 minutes of database time every hour. That query often costs more than the one slow monthly report.
  • A plain create index blocks writes to the table until the build finishes, and a schema change stuck waiting for its lock queues every later query on that table behind it. Our guide to safe releases and rollbacks covers both fixes.

Section 020 of 6 checked

Are caching and background jobs safe at higher volume?

  • Work inside a request holds a web worker, and often a database connection, for its whole duration. Twenty users starting a 10 second export at once can occupy every worker on a small deployment and stall sign-in for everyone else.
  • Most job queues deliver at least once and retry on failure. A job that is unsafe to repeat turns a timeout into a duplicate invoice, and that gets more likely as volume grows.
  • A job that always fails and retries forever crowds out healthy work. A capped retry count and a visible failed list turn a silent backlog into a short list someone can fix.
  • A job scheduled every 15 minutes takes longer as data grows, and eventually it is still running when the next one starts. Two copies processing the same rows produce duplicates or deadlocks.
  • Caching those reads in Redis or in memory for a short time takes repeated load off Postgres. A written invalidation rule stops customers from seeing old values after they edit something.
  • A key built only from the URL or the record type can serve one customer's data to another. That is a data exposure, not a performance bug, and it often appears when caching is added quickly to fix a slow page.

Section 030 of 6 checked

Does the frontend meet Core Web Vitals on real devices?

  • Google's web.dev guidance on Core Web Vitals recommends judging these at the 75th percentile of page loads, segmented across mobile and desktop. Lab scores from a fast laptop hide what customers see on mid-range phones and weak connections.
  • Bundles grow one dependency at a time, and the cost shows up as delayed taps and clicks on mid-range phones. A CI check that fails when the main bundle passes an agreed size catches a large charting or editor library before it ships to every page.
  • A screen that fetches the user, then the account, then the list adds one network round trip per step. On a mobile connection with a 150 ms round trip, those three requests in sequence cost 450 ms before any server work.
  • Images without dimensions push content down as they load, a common cause of layout shift. Full-size uploads served to small screens delay LCP, and so does lazy loading the main image at the top of the page.
  • Hashed names let browsers keep a file for a year and download a new one only when it changes. Without them, each deploy either serves stale code or makes every visitor download everything again.
  • Rendering 5,000 rows makes each keystroke in a filter box slow, which shows up as poor INP. The interface needs the same limit as the API, or the frontend undoes what pagination saved.

Section 040 of 6 checked

Do you know where your infrastructure limits are?

  • The default max_connections is typically 100, according to the Postgres connection settings documentation, and managed hosts often set it by instance size. Every app instance or serverless function opens its own connections, so scaling out can exhaust the limit, and the database then refuses new connections while its CPU sits idle.
  • An app that keeps sessions in memory or files on local disk works on one server and breaks on two. Rolling deploys, autoscaling, and failover all assume any instance can serve any request.
  • Some HTTP clients have no default timeout, Python's requests library among them. When a provider slows down, your requests pile up waiting on it, and its outage becomes yours.
  • Email, payment, maps, and AI model APIs limit requests per second or per minute. Hitting a limit during a launch or a bulk import looks like a bug in your app unless calls back off and fail in a defined way.
  • One customer's script looping over your API, or a bot hitting sign-up, can use capacity meant for everyone. A per-tenant limit keeps one account's spike from becoming every account's slowdown.
  • Append-only tables grow fastest and are rarely cleaned up. Backups, vacuum, and index builds slow down as they grow, and a full disk can take the database offline.

Section 050 of 7 checked

Does load testing show your app will handle more users?

  • A load test answers whether the app will handle more users with a measurement instead of a guess. Tools such as k6 or Locust script the requests, and testing above peak shows how much margin you have before response times climb.
  • Missing indexes and N+1 queries barely show on a near-empty database. Use a copy with personal data removed, or generated data at real row counts, or the test proves little.
  • Hitting one cached endpoint as fast as possible only measures the cache. Real traffic mixes page views, saves, and the jobs they trigger, and the job queue is often what falls behind first.
  • A healthy-looking average can hide one request in fifty taking four seconds. Those slow requests tend to come from the largest accounts running the heaviest pages.
  • The most useful result of a load test is the first bottleneck and the load at which it appears. It tells you what to fix before growth arrives, and what not to spend money on.
  • A load test that sends thousands of real emails or API calls can hit provider limits, run up charges, or get an account suspended. Stubs keep the test focused on your own system.
  • Capacity changes as features ship, so last year's result describes a different app. A rerun before a known traffic jump tells you whether the margin still holds.

Section 060 of 6 checked

Will you see slowdowns before customers report them?

  • An uptime check passes while a dashboard takes eight seconds to load. Per-endpoint percentiles show which route got slower and when it started, often right after a specific deploy.
  • Without traces, a slow page starts a guessing game between frontend, API, and database. A trace shows the span that took the time, such as 40 small queries or one 3 second call to a payment provider.
  • Tags show whether an error hits one account or all of them, and whether the last deploy caused it. That answer decides between a quick fix and a rollback.
  • CPU alerts alone fire too often or too late, and a queue can fall hours behind while every server looks healthy. Symptom alerts with an owner mean someone acts before a customer emails support.
  • The database is the hardest part of most web apps to scale out, so it is usually the first hard limit. Connections creeping toward the limit give warning well before requests start failing.
  • One request ID turns three tools into one timeline. Unstructured logs without it are hardest to search during an incident, which is when you need them most.

Section 070 of 5 checked

Does cost grow more slowly than usage?

  • Total spend rising with revenue is expected. Cost per customer rising means something scales worse than the business, such as a query, log volume, or an AI feature, and the bill shows it before the margin does.
  • A retry loop, a runaway job, or a leaked API key can multiply a bill within days. An alert at a set threshold catches it early instead of on the monthly invoice.
  • Usage-based services are cheap at low volume and grow with every request. Logging full request bodies or calling a large model on every page view can cost more than the servers.
  • Capacity added during an incident is rarely removed afterward. A quarterly review keeps the bill tied to real load.
  • Pricing the next step in advance turns a scaling decision into a planned budget line instead of a weekend emergency.

0 of 43 checked

How do you score this web app performance and scalability checklist?

#

Score each group on its own, because one weak group can take the product down even when the overall total looks healthy. Count the no answers in each group and read the result from the table below.

Group resultWhat it meansWhat to do
Every check yesReady for the next jump in usageRerun before launches and big onboardings
One or two noKnown gaps that will surface as usage growsSchedule the fixes, urgent ones first
Three or more noThe likely source of your first outageFix before any planned traffic jump
Reading each group's result

Which failures are urgent?

#

Fix these first. Each one gets worse as data and traffic grow without any code change, exposes customer data, or leaves customers to find failures before you do.

  • A query per row, unpaginated lists, or missing indexes on tables that grow with every customer.
  • No connection pooling on an app that scales out or runs on serverless functions.
  • Slow third-party calls inside web requests with no timeout.
  • Cache keys without the tenant, which can show one customer's data to another.
  • No alerts on errors, latency, or queue age, so customers report failures before you see them.

When does an outside review make sense?

#

Get outside help when several groups score low, nobody owns performance, or a launch or large customer is weeks away. If we already know your code, an engineering retainer puts monthly capacity on the fixes. From the Maintain tier upward, we also watch errors, uptime, and slow queries. Improve, at 50 hours a month, leaves room for performance work alongside new features.

For a product someone else built, start with a software audit, a fixed-fee review from $2,500 that ranks these risks in a written report. If the failures trace back to the schema itself, read our guide to deciding whether to rebuild or refactor. If slow pages sit in code the team avoids changing, the technical debt triage checklist sorts what to fix now and what can wait.

Checklist updates

Get an email when this checklist changes

We revise checklists when tools or advice change. Leave your email and we'll tell you when this one is updated. You'll also get the monthly newsletter, and every email has an unsubscribe link.

By subscribing, you agree to get the Pixelact newsletter by email. Every email has an unsubscribe link. Read the privacy notice.

FAQ

Questions about this checklist

Straight answers on what it covers, who should run it, and what to do with the results.

Nobody can tell from the outside, because the limit depends on what each user does, not on the head count. Convert users into requests first: 1,000 people active at once, each causing a request every 10 seconds, is about 100 requests per second. Load test at that rate on production-sized data, then raise it until latency or errors climb. That point is your current ceiling.

Before a known jump in usage, and as soon as existing pages slow down while accounts grow. Rebuilding for traffic you don't have yet usually costs more than it saves. The cheap checks are different: pagination, indexes on foreign keys, timeouts, and basic alerts cost little to add early. Sort the rest with the technical debt triage checklist.

No. Lighthouse runs a lab test on one simulated device and connection, and a standard page-load run can't measure INP, which needs real interactions, so it reports Total Blocking Time instead. Core Web Vitals are judged on field data from real visits, so check the Chrome UX Report in PageSpeed Insights or Search Console, or collect your own with the web-vitals library.

Usually not as a first step. Most early SaaS products go a long way on one well-indexed Postgres database, several stateless app instances, a job queue, and a cache. Splitting into services adds network calls, deployments, and failure points. Fix the failed checks first, and split a part out only when measurement shows one component needs to scale on its own.

Yes. For a product we built, an engineering retainer puts the fixes on monthly capacity. For any other product, a software audit comes first: about 3 to 5 days of review and a written report that ranks risks and fixes, as what a software audit covers explains. It doesn't include load testing against production traffic. If the audit leads to a build within 60 days, 50% of its fee is credited against the build.

Next step

Need help closing the gaps?

Tell us what you're building and what the checklist turned up, or book a call if you're not sure where to start.

On the discovery call

  1. 01What prompted this now, and where things stand
  2. 02What a good outcome looks like
  3. 03Whether we're a fit, and what a next step could be

45 minutes. No slides, and no long questionnaire.