Building Fast Websites for Pakistan's Real Network Conditions (Not Just a Lighthouse Score)

Muhammad Farzan — Sat, 01 Aug 2026 12:19:34 +0000

It's easy to test a site on office fibre, get a 95+ Lighthouse score, and call performance "done." Then someone in a secondary city mentions the site feels slow on their phone, and the gap between tested performance and real performance becomes obvious.

This isn't a Pakistan-specific problem in theory, but it's an unusually common one in practice — a large share of real users here are on congested 3G or throttled 4G, on mid-range Android devices, often outside the main metros where infrastructure is best. If you're building for a Pakistani (or generally emerging-market) audience, "works great in the office" isn't the same as "works great for the actual user."

Here's what actually moves the needle, beyond just plugging in a CDN.

A CDN helps, but it doesn't fix the last mile

A CDN gets your assets physically closer to the user, which helps. But if the connection between someone's phone and the nearest edge node is still a congested 3G link, the CDN's job is basically done — the bottleneck is the last mile, and no amount of edge-caching fixes that. What actually helps is reducing how much has to travel down that last mile in the first place.

That reframes the whole problem: less about "getting bytes there faster" and more about "sending fewer bytes."

1. Image weight is usually the biggest offender

Images are typically the single largest contributor to page weight, and the fix isn't exotic:

// Next.js example — explicit width/height prevents layout shift,
// and the Image component serves modern formats automatically
import Image from "next/image";

<Image
  src="/hero.jpg"
  alt="Product hero shot"
  width={1200}
  height={630}
  priority // only for above-the-fold images
/>

A few concrete habits that add up:

Serve WebP/AVIF instead of raw JPEG/PNG where you can — usually 25-50% smaller at equivalent visual quality
Always set explicit width/height (or use a framework component that does it for you) so the browser doesn't shift layout while images load — this also directly affects your Cumulative Layout Shift score
Lazy-load anything below the fold. No reason to spend bandwidth loading images a visitor may never scroll to

On one e-commerce rebuild, tightening just the image pipeline (format, lazy-loading, explicit dimensions) cut total page weight by roughly a third — without touching the design at all.

2. Audit every third-party script like it's costing you money (because it is)

Every third-party script — chat widgets, analytics, marketing pixels, embedded social widgets — adds parse and execution time on the client, and that cost is disproportionately higher on a low-end device than on a developer's laptop. A script that "feels instant" in Chrome DevTools on fibre can visibly block interactivity on a budget Android phone over 3G.

A simple audit habit: open your Network tab, filter by JS, and sort by size. For anything you don't immediately recognize the purpose of, ask whether it's actually earning its cost. Defer what you can:

<!-- Bad: blocks parsing immediately -->
<script src="https://widget.example.com/embed.js"></script>

<!-- Better: doesn't block initial render -->
<script src="https://widget.example.com/embed.js" defer></script>

For anything genuinely non-critical (most chat widgets, most marketing pixels), loading it after the main content is interactive — rather than in the critical path — is usually the single highest-leverage JS change you can make.

3. Self-host your fonts

Pulling fonts from a third-party CDN (Google Fonts' default embed being the most common example) adds an extra DNS lookup and connection round-trip before a single font file even starts downloading. Self-hosting removes that hop entirely:

// Example using @fontsource (self-hosted font packages)
import "@fontsource/inter/400.css";
import "@fontsource/inter/600.css";

Combine this with font-display: swap so text renders immediately in a fallback font instead of staying invisible while the custom font downloads (avoiding the classic "flash of invisible text"):

@font-face {
  font-family: "Inter";
  src: url("/fonts/inter.woff2") format("woff2");
  font-display: swap;
}

Small change, consistently measurable improvement in Largest Contentful Paint on slow connections.

4. Measure on throttled connections, not just fibre

Chrome DevTools has a built-in network throttling option ("Slow 3G" / "Fast 3G" presets under the Network tab) — genuinely underused. Testing your actual build under simulated 3G, rather than trusting a Lighthouse score generated on a fast connection, surfaces problems a lab score can hide. PageSpeed Insights' "Field Data" section (when available) is even more useful — it's based on real Chrome User Experience Report data from actual visitors, not a synthetic lab run.

None of this is exotic — that's the point

Nothing above is a clever trick. It's mostly discipline about what gets added to a page and when it loads. But that discipline is the actual difference between a site that scores well in a lab test and one that feels fast to someone on a real 3G connection in a city outside the main metros — which, for a lot of products built here, is a large and easy-to-forget part of the real audience.

I run WebTech Solutions, a web development studio based in Rawalpindi, Pakistan — we build for clients across Pakistan, the UK, the US, the UAE, and Saudi Arabia. A lot of the discipline above came from building specifically for lower-bandwidth conditions, but it holds up everywhere. Here's an example of a recent Next.js build where performance was a deliberate priority, not an afterthought.