# Web app performance and scalability checklist

URL: https://pixelactstudio.com/resources/performance-scalability-checklist

> Web app performance and scalability checklist: 43 yes-or-no checks on Postgres, caching, jobs, Core Web Vitals, load tests, and cost, each with its risk.

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](https://pixelactstudio.com/resources/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.

## Do database queries and indexes keep up as data grows?

- [ ] Do list pages and API endpoints run a fixed number of queries per request, with no extra query per row? 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.
- [ ] Does every list endpoint paginate, with a maximum page size enforced on the server? 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.
- [ ] Are the columns used in `where`, `join`, and `order by` clauses on large tables indexed, including foreign key columns? Postgres indexes primary keys and unique constraints automatically, but [the Postgres documentation on constraints](https://www.postgresql.org/docs/current/ddl-constraints.html) 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.
- [ ] Do multi-tenant tables have composite indexes that start with the tenant column, such as `(tenant_id, created_at)`? 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.
- [ ] Have you run `explain analyze` on your slowest queries, against production-sized data, and confirmed none reads a whole large table to return a few rows? 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.
- [ ] Is `pg_stat_statements`, or your database host's query insights, turned on so you can rank queries by total time? 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.
- [ ] Do migrations on large tables avoid long locks, for example with `create index concurrently` and a short `lock_timeout`? 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](https://pixelactstudio.com/blog/safe-releases-and-rollbacks) covers both fixes.

## Are caching and background jobs safe at higher volume?

- [ ] Do slow work and third-party calls, such as emails, PDF exports, imports, and AI model calls, run in background jobs rather than inside web requests? 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.
- [ ] Are background jobs idempotent, so running one twice does not send a second email or charge a card twice? 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.
- [ ] Does every job type have a timeout, a retry limit with backoff, and a failed state that someone reviews? 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.
- [ ] Are scheduled jobs protected from overlapping runs, for example with a lock? 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.
- [ ] Is data that is read far more often than it changes, such as plan limits, settings, and dashboard totals, cached with a defined expiry or invalidation rule? 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.
- [ ] Do cache keys include the tenant, and the user for user-specific data? 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.

## Does the frontend meet Core Web Vitals on real devices?

- [ ] Do your main pages meet the Core Web Vitals thresholds for real visitors: LCP within 2.5 seconds, INP of 200 ms or less, and CLS of 0.1 or less? Google's [web.dev guidance on Core Web Vitals](https://web.dev/articles/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.
- [ ] Is the JavaScript loaded by your main screens measured, with a size budget checked in CI and heavy screens split into separate chunks? 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.
- [ ] Do the data requests on each screen run in parallel instead of waiting on each other? 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.
- [ ] Do images have a set width and height, a modern format such as WebP or AVIF, and lazy loading below the fold only? 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.
- [ ] Are static assets served from a CDN with content-hashed file names and long cache headers? 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.
- [ ] Do long tables and lists use server pagination or virtualized rendering instead of thousands of DOM rows? 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.

## Do you know where your infrastructure limits are?

- [ ] Do you know your database connection limit, and does the app connect through a pooler such as PgBouncer or your host's built-in pooler? The default `max_connections` is typically 100, according to [the Postgres connection settings documentation](https://www.postgresql.org/docs/current/runtime-config-connection.html), 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.
- [ ] Can the app run as several identical instances, with no sessions, uploads, or job state kept in one server's memory or on its disk? 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.
- [ ] Does every outbound HTTP call have a timeout? 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.
- [ ] Do you know the rate limits of every third-party API on a busy path, and what the app does when it hits one? 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.
- [ ] Do expensive and public endpoints have rate limits per user, per tenant, or per IP address? 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.
- [ ] Are disk usage and the growth of large tables tracked, with event, log, and audit tables on a retention or partitioning plan? 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.

## Does load testing show your app will handle more users?

- [ ] Have you load-tested your most-used requests at two to three times your expected peak traffic? 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.
- [ ] Does the test database hold production-sized data, including an account as large as your biggest customer? 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.
- [ ] Does the test mix realistic behavior: sign-ins, reads and writes, uploads, pauses between actions, and the background jobs those actions start? 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.
- [ ] Do you record p95 and p99 latency and the error rate during the test, not only the average? 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.
- [ ] Did the test show which component reaches its limit first: app CPU, database CPU, connections, the job queue, or a third-party quota? 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.
- [ ] Does the test run against a staging environment, with payments, email, and other third-party calls stubbed or in test mode? 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.
- [ ] Do you rerun the load test before launches, large customer onboardings, and major architecture changes? 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.

## Will you see slowdowns before customers report them?

- [ ] Do you track p50, p95, and p99 latency per endpoint, not only uptime? 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.
- [ ] Can you trace one slow request across the app, the database, and outbound calls, for example with OpenTelemetry? 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.
- [ ] Do errors reach an error tracker tagged with the release, the tenant, and the user ID? 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.
- [ ] Do alerts fire on symptoms customers feel, such as error rate, p95 latency, and the age of the oldest queued job, and reach a named person? 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.
- [ ] Do you watch database health: connections in use against the limit, slow queries, replication lag, and free disk? 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.
- [ ] Do logs share a request ID with traces and errors, in a structured format you can search? 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.

## Does cost grow more slowly than usage?

- [ ] Do you know your infrastructure cost per active customer, and how it moves month to month? 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.
- [ ] Are budget alerts set on cloud, database, and paid API accounts? 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.
- [ ] Do you know which features drive usage-based cost, such as AI model calls, storage, data transfer out, and log ingestion? 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.
- [ ] Do you review running resources each quarter for idle instances, oversized databases, forgotten preview environments, and old snapshots? Capacity added during an incident is rarely removed afterward. A quarterly review keeps the bill tied to real load.
- [ ] Do you know the next scaling step and its monthly cost, such as a larger database instance or a read replica, before you need it? Pricing the next step in advance turns a scaling decision into a planned budget line instead of a weekend emergency.

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

**Reading each group's result**

| Group result | What it means | What to do |
| --- | --- | --- |
| Every check yes | Ready for the next jump in usage | Rerun before launches and big onboardings |
| One or two no | Known gaps that will surface as usage grows | Schedule the fixes, urgent ones first |
| Three or more no | The likely source of your first outage | Fix before any planned traffic jump |

### 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](https://pixelactstudio.com/services/engineering-retainers) 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](https://pixelactstudio.com/services/software-audits), 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](https://pixelactstudio.com/blog/rescue-or-rebuild). If slow pages sit in code the team avoids changing, the [technical debt triage checklist](https://pixelactstudio.com/resources/technical-debt-triage-checklist) sorts what to fix now and what can wait.

## Frequently asked questions

### How many users can my web app handle?

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.

### When should a startup start worrying about scalability?

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](https://pixelactstudio.com/resources/technical-debt-triage-checklist).

### Is a good Lighthouse score enough to pass Core Web Vitals?

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.

### Do we need microservices or Kubernetes to scale?

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.

### Can Pixelact run this checklist on our product?

Yes. For a product we built, an [engineering retainer](https://pixelactstudio.com/services/engineering-retainers) puts the fixes on monthly capacity. For any other product, a [software audit](https://pixelactstudio.com/services/software-audits) comes first: about 3 to 5 days of review and a written report that ranks risks and fixes, as [what a software audit covers](https://pixelactstudio.com/blog/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.