I Tested My Site Speed From 5 Different Countries: The Results Surprised Me
At first, I thought it was nothing unusual. But as I kept watching the analytics, I was genuinely shocked at the massive gap in performance.

One day, I was showing my newly developed website to my uncle, who lives in the United States. He opened my URL on his end, and the website loaded almost instantaneously he barely had to wait a second. Meanwhile, I was sitting right here at my workstation in Pakistan where I wrote the code, and the exact same page was taking noticeably longer to render on my screen.
Same site. Same exact moment. Two completely different user experiences.
That small observation sent me down a technical rabbit hole I wasn’t expecting. What I found completely changed how I approach web architecture and performance optimization at my agency today.
What I Assumed vs. The Reality of Network Latency
Before this moment, I operated on a very simple assumption: If my website loads fast on my local machine, it loads fast for everyone. I built the site, my internet connection was solid, so naturally, my experience would be representative of global users.
I was wrong in the most direct way possible.
When I started investigating why my uncle’s experience was so vastly different from mine, I collided with a fundamental rule of network engineering: server location affects loading speed in a very physical way.
Data has to physically travel through fiber-optic cables from the hosting server to the user’s browser. The greater the geographic distance, the longer the journey. This delay is known as latency, and it directly impacts a metric called TTFB (Time to First Byte).
My hosting servers were located in the US. My uncle was geographically close to that data center. I was thousands of miles away in Pakistan. So, despite me being the developer and owner of the site, his page loaded drastically faster than mine.
That felt backwards to me at first. But from a network architecture perspective, it made complete sense.
The Experiment: Testing From 5 Different Countries
Once I understood the mechanics of latency, I wanted to see the full, raw picture. Not just my local network versus the US, but a wider range of global locations to map exactly how much variation existed.
I ran my website through performance testing tools specifically GTmetrix and Google PageSpeed Insights from five different geographic nodes:
-
My own location (Pakistan)
-
United States (US)
-
Canada
-
United Kingdom (UK)
-
United Arab Emirates (UAE)
I made zero optimization changes before testing. I wanted to see the raw, unedited numbers first before I touched the caching or the server configuration.
The Results, Country by Country
-
United States: This was the fastest result by a massive margin. The site fully loaded in around 2 seconds. This lined up perfectly with my uncle’s experience and confirmed my hypothesis: because my hosting server was in a US data center, local users had virtually zero latency.
-
Canada and the UK: These yielded highly acceptable results. Geographically, data traveling from a US server to Canada or across the Atlantic to the UK happens relatively quickly. The TTFB was slightly higher than the US, but the user experience remained smooth.
-
Pakistan (My Location): This is where the data surprised me. From my own desk, my site was taking around 6 seconds to fully load. If the browser cache was cleared, it sometimes pushed even higher. For months, I had assumed my local ISP was just having a slow day whenever my site felt sluggish. The real culprit was the physical server distance.
-
UAE: This was the slowest result of all five, consistently hitting the 6 to 7-second mark. The UAE is geographically far from US-based servers, and without a specialized network to bridge that gap, users in the Middle East were getting a noticeably degraded experience.
The Moment That Hit Differently
Finding out that my own site loaded the slowest for me personally was a massive wake-up call.
I had been sitting at my desk for months, noticing the sluggishness, and wrongly blaming my WiFi. If I hadn’t conducted this multi-country test, I would have kept optimizing the site’s code based on my own experience which was actually the worst-case geographic scenario.
More importantly, I realized that users in regions like the UAE who form a highly profitable demographic for digital services were getting an unacceptable user experience.
The Core Infrastructure Gaps

The speed gap existed because of two missing pieces in my web architecture at the time:
-
Lack of a CDN (Content Delivery Network): A CDN stores cached copies of your website’s static assets (images, CSS, JavaScript) on “Edge Servers” located in dozens of countries around the world. When someone in the UAE visits your site, a CDN serves the files from a local node in Dubai rather than forcing the data to travel all the way from the US. Because I didn’t have a CDN active, the sheer physical distance was bottlenecking my load times.
-
Unoptimized Payload: While some of my images were compressed, others were not delivered in next-gen formats (like WebP). For a user geographically close to the server, a heavy image loads fine. But for a user 8,000 miles away, every unoptimized kilobyte compounds the latency issue.
The 3 Fixes That Solved the Global Speed Gap
Armed with this data, I immediately deployed three structural changes to the site:
-
Strict Image and Asset Optimization: I audited the entire media library, compressing every image and serving them in WebP format. I also minified the CSS and JavaScript payloads to ensure the total page size was as light as physically possible.
-
Deploying an Enterprise-Grade CDN: This was the game-changer. I routed the domain through a global CDN. Instantly, content started serving from Edge nodes nearest to the visitor. The heavy lifting was no longer relying solely on the origin server in the US.
-
Aligning Server Location with Target Audience: While my content is global, I realized the importance of deploying origin servers closest to where the majority of my primary audience resides.
After these deployments, I ran the GTmetrix tests again. The global performance gap collapsed. Load times in the UAE and Pakistan dropped dramatically, aligning much closer to the high speeds experienced in the US.
The Client Case Study: Fixing the Same Issue at CubeCod Technologies
Shortly after my own experiment, a client approached my agency, CubeCod Technologies, with a nearly identical problem.
They were running a mid-sized e-commerce operation. They complained that their site felt incredibly slow, causing high bounce rates, but they had no idea why. When I audited their analytics, I found that 70% of their paying traffic was coming from Europe and the Middle East, but their hosting server was sitting in a cheap data center on the US West Coast. Furthermore, they had massive, unoptimized hero images and zero CDN routing.
I explained the concept of server latency to them, deployed a CDN, optimized their database queries, and compressed their assets. The loading speed dropped by over 4 seconds globally. The improvement was so drastic that the client noticed it immediately on their mobile device without me even sending the final report.
What Most Developers Get Wrong (And How to Test It Yourself)

I have watched incredibly talented developers test their site speed once using their local localhost or an isolated local connection, see a fast load time, and push the site to production feeling satisfied.
Local speed is a trap. It is the single data point that is most favorable to you and least representative of your global audience.
You do not need expensive enterprise tools to avoid this mistake. Here is the exact testing protocol I use today:
-
Google PageSpeed Insights: Run your URL here to get a baseline score for Core Web Vitals.
-
GTmetrix / WebPageTest: Use these tools to change the physical testing location. Run your site from the US, London, Sydney, and Mumbai.
-
Analyze the TTFB: If one region is significantly slower, check your CDN routing and ensure your edge caching rules are actually working.
Final Thoughts: Stop Optimizing Blindly
Before I write a single line of optimization code for a project at CubeCod, I check two things: Where is the origin server? and Where is the actual audience coming from?
If those two locations are completely mismatched and a CDN isn’t bridging the gap, no amount of code minification is going to save your load times. Running that five-country test taught me more about practical web performance in a single afternoon than months of reading server documentation.
If you have never tested your website from a country other than your own, do it today. The results might shock you.
