How Nept's Global Edge Network Performs Across Regions

Nept runs edge nodes in three regions — US-East (Ashburn, VA), EU-West (Paris, FR), and AP-South (Mumbai, IN) — and publishes live health, latency, and uptime figures for each. Based on the platform's own status data, latency ranges from 38 ms in Ashburn to 52 ms in Mumbai, with uptime between 99.994% and 99.998%. That spread is the practical answer to whether Nept can serve a globally distributed audience: it can, but the region closest to your users will always be the fastest, and the gap between regions is roughly 6–14 ms.

What the three regions actually report

All three report "Healthy" and "All systems operational." The numbers move in a consistent direction: the US-East node is the lowest-latency, and each subsequent region adds a few milliseconds. Uptime is highest in US-East and lowest in AP-South, though the difference is 0.004 percentage points — small enough that it shouldn't drive a deployment decision on its own.

Why the latency numbers differ

The three regions are physically separated, so requests travel different distances. A user in North America hitting iad1 gets a shorter round trip than a user in India hitting bom1. Nept's model is to place edge nodes close to users so each request resolves at a nearby node rather than crossing an ocean. The published latency figures are the platform's own measurements of that proximity effect.

Two caveats worth keeping in mind:

• These are platform-reported numbers, not a third-party benchmark. They describe Nept's nodes, not your specific application's response time. Your app's own latency depends on where your database, API, and build artifacts live.
• Latency is measured to the edge, not end-to-end. If your app calls an origin server or database in a single region, users in other regions still pay that backhaul cost. Edge functions and static assets benefit most; stateful backends need their own regional strategy.

What this means for choosing a region

The region you pick should follow your users, not the lowest number in the table.

• Mostly North American users → deploy to iad1. It has the best latency and uptime in the published data.
• Mostly European users → cdg1, at a 6 ms penalty versus US-East.
• Mostly South Asian users → bom1, at a 14 ms penalty versus US-East.
• Globally spread users → rely on the edge network to serve each user from the nearest node, and keep latency-sensitive backend logic close to the largest user cluster.

For static assets and edge functions, the regional differences are small enough that the edge distribution does most of the work. For anything that hits a single-region database, the region choice matters more than the edge layer, because every request outside that region crosses a longer path.

How to verify performance for your own workload

The status figures tell you about Nept's infrastructure, not your app. To check your actual numbers:

1. Deploy the app and note which region serves it.
2. Use the per-branch preview URL (for example, feat-xyz.app.nept.cloud) to test a build before it reaches production.
3. Measure response times from locations that match your real user base — a latency test from your own machine only tells you about your own path to the nearest node.
4. Compare against the published baseline: if you're seeing far more than 38–52 ms, the bottleneck is likely your origin, database, or function cold start rather than the edge node.

Common pitfalls

• Assuming "global" means identical latency everywhere. It doesn't. The edge reduces distance; it doesn't eliminate it.
• Reading uptime as a guarantee. 99.994%–99.998% is a historical status snapshot, not a contractual SLA. Check the pricing or terms page for any formal commitment.
• Ignoring cold starts. Nept advertises cold starts under 30 ms for serverless functions, which is in the same range as the regional latency differences — so for infrequently called functions, cold start can matter as much as region choice.
• Treating the three regions as full redundancy. They're three points of presence, not a multi-region failover guarantee. If your app needs active-active across regions, that's an architecture decision you make on top of the platform, not something the region list provides automatically.

Bottom line

Nept's edge network covers three regions with healthy status, sub-55 ms latency, and uptime above 99.99%. Pick the region nearest your users, expect a 6–14 ms penalty for the farther regions, and verify your own end-to-end numbers rather than relying on the platform's edge measurements alone. The edge layer handles distribution well; your database and backend placement still determine whether users everywhere get the same experience.