digi.ai.in
← digi.ai.in / blog
2026-08-179 min readPerformance

How Much of "It's Slow" Is Actually a Database Problem?

Often most of it — but there's no fixed percentage, and India's mobile-first networks make the cost of a slow database worse.

If your team is calling your website or app "slow" without any further detail, there's a good chance the database is doing most of the damage — hidden inside a number called Time to First Byte. There's no clean industry percentage that says "X% of slowness is database-caused," but the diagnostic path is well established, and for founders and ops managers in India, the stakes are higher because the underlying mobile networks are already slower than in most markets we get compared against.

This post walks through where "slow" actually comes from, what a database problem looks like in practice, whether speed really costs sales, and what's different about running a site for an Indian audience.

Start with TTFB, not vibes

When someone says a site "feels slow," the first measurable thing to check is Time to First Byte (TTFB) — the gap between the browser sending a request and the server sending back the first byte of a response. Google's own performance documentation explains that TTFB precedes user-facing metrics like First Contentful Paint and Largest Contentful Paint, and recommends servers respond fast enough that 75% of users get a "good" FCP. Google's rough benchmark is that most sites should aim for a TTFB of 0.8 seconds or less, with anything above 1.8 seconds considered poor.

The scale of the problem becomes clear when you look at real-world data. The 2025 Web Almanac found that sites with poor LCP scores spend an average of 2.27 seconds on TTFB alone — nearly the entire 2.5-second LCP budget, before the browser has even started rendering anything. In other words, on a lot of "slow" sites, the server-side wait is eating the whole performance budget before the front end gets a chance.

One nuance worth flagging here, because it trips people up: TTFB is often described online as a Core Web Vital. It isn't. Google's own documentation is explicit that TTFB isn't a Core Web Vitals metric, so a site isn't required to hit the "good" TTFB threshold to pass Core Web Vitals, and a dedicated Core Web Vitals resource confirms that the three actual Core Web Vitals are LCP, INP, and CLS — TTFB isn't one of them, and Google doesn't use it directly as a ranking signal. TTFB still matters — it's the diagnostic root cause behind slow LCP scores — it's just not the metric Google grades you on directly.

So what actually drives TTFB up? A commonly cited breakdown notes that once a connection is established, the server has to send the data — and limited hardware capacity, poorly configured servers, unnecessary plugins, and slow-reacting databases all delay that transmission. That last item — slow-reacting databases — is where this post is headed.

What a database problem actually looks like

"The database is slow" isn't a diagnosis, it's a symptom. Here's what the actual causes tend to be, according to database engineering sources:

Cause What it looks like Source
Slow queries Queries with poor execution plans, missing indexes, stale statistics Microsoft Azure SQL docs
Resource limits CPU, memory, or disk I/O bottlenecks on the database server itself Paessler
N+1 queries One query per row instead of one batched query N+1 query guide
Missing or bad indexes The database scans more rows than it needs to Microsoft Azure SQL docs

Microsoft's Azure SQL documentation goes a level deeper on why queries go bad in the first place: a suboptimal query plan is often produced because of a missing index, stale statistics, an incorrect estimate of rows to be processed, or an inaccurate memory estimate. And when the query plan itself isn't the problem, Microsoft notes that slow performance not related to query plans or missing indexes is generally tied to hitting resource limits on the database itself — meaning the box (or the plan you're paying for) is simply undersized for the load.

The N+1 problem: the silent app-killer

If your app is built on an ORM (Django, Rails, Laravel, most modern frameworks), there's a specific and very common failure mode called the N+1 query problem: your code fetches a list of, say, 50 orders, then fires one extra database query per order to get its details — 51 queries where one would do.

A developer guide on this describes the impact bluntly: a single N+1 query can turn a 100ms page load into a 10-second nightmare, costing real money in cloud hosting fees and driving users away. There's a simple tell for it too: when doubling your data doubles your response time instead of causing only minimal impact, N+1 queries are often the culprit. If your admin dashboard was fine with 200 rows and crawls with 2,000, this is the first thing to check.

How to actually find out

You don't have to guess. Database analyst Prisma's diagnostic guide recommends a specific starting point: query statistics reports from your cloud database provider are often the best source of information for finding slowdowns, since in many cases the slowdown traces back to specific queries that take a long time to execute. Every major managed database (RDS, Cloud SQL, Azure SQL, most Postgres/MySQL hosts) exposes this — it's usually a five-minute check, not a research project.

A basic checklist for a team investigating "it's slow":

  1. Measure TTFB on the actual pages users complain about, not just the homepage.
  2. Pull the slow-query log or query statistics report from your database provider.
  3. Check if response time scales linearly with data volume — if it doesn't, look for N+1 patterns.
  4. Confirm whether the database is hitting CPU, memory, or disk I/O limits, not just slow on individual queries.
  5. Check for missing indexes on the specific tables involved in the slow queries.

Does speed actually cost you sales?

Yes, directionally — but the exact numbers you'll find quoted online are inconsistent, and it's worth being honest about that rather than picking whichever stat sounds best.

Commonly repeated figures include:

But the source that aggregates the Amazon/Google/Akamai-era figures is upfront about the disagreement between them: site speed clearly has a direct impact on conversion rates and revenue, but exactly how big that impact is, is much harder to determine, because these studies span different companies, years, and traffic types, and shouldn't be treated as universal constants. Use them as directional evidence that speed matters — not as a formula you can plug your own revenue into.

What's different about India

This is where the database question gets more urgent, not less. India's networks are a genuinely different starting point than the US or Western Europe studies these stats usually come from.

TRAI's own regulatory definition of broadband is modest: a minimum download speed of 2 Mbps to an individual subscriber — a floor that was only raised from 512 kbit/s in 2013 to 2 Mbit/s in 2023. On mobile, where the majority of Indian users are, the country ranks 78th globally with an average mobile download speed of 56.2 Mbps, despite being home to over 1 billion internet users and 70% internet penetration as of 2025.

The base is growing fast regardless — broadband subscribers reached 995.63 million by the end of September 2025 — but fixed-line infrastructure remains thin: an earlier TRAI recommendation paper found fixed broadband penetration in India is among the lowest in the world at only 1.69 per hundred inhabitants.

What this means practically: a lot of Indian users are hitting your site over mobile networks with more baseline latency than the fiber-and-desktop conditions in most of the speed-vs-revenue studies above. A 500ms-slow database query doesn't happen in isolation — it stacks on top of a slower network round trip that's already there before your server even gets the request. There is no India-specific study in the sources we reviewed that quantifies exactly how much worse this compounding effect is — that's a real gap in the data, not something to paper over with an invented number. But the directional logic holds: if your audience is mostly mobile in India, the case for fixing database-level slowness is stronger, not weaker, than it would be for a desktop-heavy US audience.

What to actually do about it

If "it's slow" has become a recurring complaint from users or your own team, don't start with a redesign or a server upgrade. Start with measurement:

  • Check TTFB on the specific slow pages, not the homepage.
  • Pull the query statistics report from your database provider and look for the slowest queries by total time, not just single-query duration.
  • Test whether response time scales with data volume — a strong signal of N+1 issues in ORM-based apps.
  • Only after that, look at whether the database server itself is under-provisioned on CPU, memory, or I/O.

In most cases, this is cheaper and faster to fix than people expect — a missing index or a batched query can turn into a dramatic real-world speedup, without touching hosting plans or front-end code at all.

Questions people also ask

Is TTFB the same thing as a Core Web Vital?

No. Google is explicit that TTFB isn't a Core Web Vitals metric, and a dedicated resource confirms the three actual Core Web Vitals are LCP, INP, and CLS, with Google not using TTFB directly as a ranking signal. TTFB is still the best early diagnostic for slow LCP, it's just graded differently.

How do I know if my slowness is an N+1 query problem specifically?

The clearest tell is that response time roughly doubles when your data volume doubles, instead of scaling only slightly. If a page was fine with a small dataset and crawls once real data volume shows up, check for one-query-per-row patterns in your ORM code.

Do I need fancy tools to find slow database queries?

No. Query statistics reports from your cloud database provider are often the best source of information for finding slowdowns, and most managed database platforms expose this by default — it's usually a quick check rather than a new monitoring purchase.

Written by the studio behind digi.ai.in. Questions? hi@digi.ai.in or WhatsApp +91 98605 96905
WhatsApp us