nept.cloud

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.

A free hosted REST API like ReqRes gives you a real HTTP endpoint you can call immediately—no signup, no local server, no database setup. You get predictable JSON responses for users, resources, login, and registration, which makes it useful for front-end demos, integration tests, learning HTTP clients, and prototyping. What it is not is a production backend for your app: the data is shared, resets periodically, and you don't control the schema. If you need persistent, private data with auth and logs, that's where an account-based backend or a commercial licence comes in.

What "free REST API for testing and prototyping" actually means

The phrase sounds vague, so it helps to separate two things people often conflate:

• A mock/sample API — a public, hosted service with fixed or semi-fixed endpoints that return realistic-looking JSON. You don't own the data. It exists so you can point code at a URL and get a response.
• A real backend you configure — a service where you define collections, schemas, authentication, and logging, and where your data persists and belongs to you.

ReqRes's landing page describes both: a free REST API for testing and prototyping with real responses and no signup, plus an option to build your own backend with collections, auth, and logs at app.reqres.in. Those are different products with different trade-offs. The free public endpoints are the "point and go" part; the account-based backend is the "own your data" part.

What you can do with the no-signup public endpoints

1. Front-end demos without a backend

If you're building a UI and need data to render, you can fetch from a public endpoint instead of hardcoding arrays. This keeps your demo code closer to real fetch logic:

async function loadUsers(page = 1) {
  const res = await fetch(`https://reqres.in/api/users?page=${page}`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const { data, total, page: current } = await res.json();
  return { users: data, total, page: current };
}

You get pagination fields, a data array, and support metadata—enough to build list views, loading states, and empty states.

2. Integration and contract tests

You can assert that your HTTP layer handles status codes, headers, and JSON shapes correctly. Typical checks:

• GET /api/users/2 returns 200 with a data object.
• GET /api/users/23 returns 404 (a non-existent user).
• POST /api/login with valid credentials returns a token; with missing fields returns 400.

This is useful for testing your client wrapper, retry logic, error handling, and serialization—without spinning up your own server.

3. Learning HTTP clients and tooling

If you're new to fetch, Axios, curl, Postman, or HTTPie, a hosted API is a low-friction target. You can practice:

• Sending query parameters (?page=2, ?delay=3).
• Setting headers and reading response headers.
• Handling POST, PUT, PATCH, DELETE.
• Observing status codes for success and failure.

4. Deliberate failure and latency testing

Endpoints that return 404 on purpose, or that accept a delay parameter, let you test how your app behaves when things go wrong or slow down. That's hard to do reliably against a happy-path local mock.

What the public endpoints are not good for

The key limitation: you don't own the data, and other people are hitting the same endpoints. Treat responses as illustrative, not authoritative.

When you'd move to an account-based backend

Consider app.reqres.in (collections, auth, logs) when any of these are true:

• You need your own collections and fields, not the fixed demo schema.
• You need data to persist between sessions and belong only to you.
• You need real authentication flows you can rely on in a demo or internal tool.
• You need request logs to debug what your client actually sent.
• You're working with a team and need shared, stable endpoints.

The trade-off is setup and, eventually, cost. The public endpoints require none; the backend requires an account and configuration.

Where pricing and licensing become relevant

The site signals a commercial licence and an upgrade path (with Stripe as the payment platform), but specific prices, plan tiers, and limits aren't stated here—so don't assume numbers. What you can reason about:

• Prototyping and learning → free public endpoints are usually enough.
• Internal tools, demos for clients, or anything you don't want reset → an account-based backend is the natural next step.
• Production or commercial use → check the licence terms and any paid plan, because "free for testing" and "free for commercial production" are not the same thing.

Before committing, read the current terms on the site rather than relying on secondhand summaries, since pricing and licence scope change.

A quick decision checklist

1. Do you need data that persists and is private? If yes → account-based backend.
2. Do you need a custom schema? If yes → account-based backend.
3. Are you only testing HTTP behavior, UI rendering, or learning a client? If yes → free public endpoints.
4. Will this touch real users or revenue? If yes → review the licence and any paid plan first.
5. Do you need logs and team access? If yes → account-based backend.

If you answer "no" to 1, 2, 4, and 5, the free hosted API is likely all you need. If you answer "yes" to any of them, plan for the account-based path.

Nept is a cloud platform for developers to deploy, host, and scale frontend and full-stack applications. You connect a Git repository, push code, and Nept builds and deploys it automatically to a global edge network. It's aimed at developers and teams who want to ship applications without managing servers or configuring DevOps pipelines.

How Nept works

The workflow is built around Git pushes rather than manual deployment steps:

1. Push your code — Connect a repository from GitHub, GitLab, or Bitbucket. Every push triggers an automatic build.
2. Auto-deploy — Nept builds, optimizes, and deploys the app. The site cites builds completing in seconds (for example, "done in 4.2s") using content-addressed caching and remote build workers.
3. Go global — The app goes live on edge nodes without extra configuration, so users are served from locations close to them.
4. Preview and iterate — Every branch gets its own preview URL (e.g., feat-xyz.app.nept.cloud) for team review before merging to production.

What you can deploy

Nept is framework-agnostic. According to the site, it auto-detects build settings for major frameworks including Next.js, Svelte, Astro, Remix, and Qwik, and supports custom Dockerfiles for everything else. The platform describes itself as supporting frameworks, containers, and edge functions through one deploy pipeline.

Core features

The site reports region latency of 38 ms (US-East), 44 ms (EU-West), and 52 ms (AP-South), with uptime figures of 99.998%, 99.996%, and 99.994% respectively.

Who Nept is for

Nept targets developers and teams who want to ship frontend or full-stack applications quickly without handling infrastructure. It fits well if you:

• Already use Git-based workflows and want push-to-deploy
• Want preview environments per branch for team review
• Need edge functions for auth, personalization, or A/B testing
• Prefer pay-per-request serverless scaling over provisioning servers

It's less relevant if you need deep control over underlying infrastructure or have requirements outside the supported framework and container model.

Pricing

Nept lists a pricing page at nept.cloud/pricing. The available material does not specify plan details, costs, or whether a free tier exists, so check that page directly for current terms.

Nept is a framework-agnostic deployment platform, so you can ship almost any frontend, full-stack, or containerized app as long as it builds from a Git repository or a Dockerfile. If your project is a Next.js, Svelte, Astro, Remix, or Qwik app, or anything that fits in a Docker container, Nept can host it. The main condition is that your code lives in GitHub, GitLab, or Bitbucket, since every deployment is triggered by a git push.

Frameworks and app types Nept supports

Nept auto-detects build settings for major frameworks and falls back to your own Dockerfile for everything else. That means you don't write deployment config for common stacks, and you aren't locked out if you use something unusual.

The platform describes itself as "framework-agnostic — we support them all," with auto-detection for every major framework and Dockerfile support "for the rest." So the practical answer is: if it builds, it deploys.

Frontend and full-stack applications

This is the core use case. You connect a repository, and every push triggers an automatic build and deploy. The site's own walkthrough shows the flow:

1. Push your code — connect your Git repo; every push triggers a build. Works with GitHub, GitLab, and Bitbucket.
2. Auto-deploy — Nept builds, optimizes, and deploys. The example shows a build finishing in about 4.2 seconds, with smart caching to keep later builds fast.
3. Go global — your app goes live on edge nodes with zero config, so users get responses from a node near them.
4. Preview and iterate — every branch gets its own preview URL (for example, preview: feat-xyz.app.nept.cloud) so you can share with your team before merging.

Edge functions

Nept supports lightweight TypeScript functions deployed globally with a single command. The platform positions these for auth, personalization, A/B tests, and low-latency APIs. If your app needs small pieces of logic running close to users rather than a full server, this is the deployment type to use.

Containerized apps via Dockerfile

If your stack isn't one of the auto-detected frameworks, you can supply a custom Dockerfile. This is the escape hatch that makes "framework-agnostic" meaningful — you're not limited to the supported list.

How deployment is triggered

Nept is Git-driven. There's no separate upload step described in the platform's flow; the trigger is a push:

git push origin main

That push starts the build. The platform reports the deploy status inline (the example shows nept deploying... done in 4.2s), and on success your app is live globally. Branch pushes produce preview URLs instead of production deploys, which is how you review changes before merging.

What comes with every deployment

These are defaults rather than add-ons, which matters when you're deciding whether Nept fits your project:

• Automatic TLS certificates on every domain
• DDoS mitigation and a WAF with managed rules, always on
• Serverless scaling — cold starts under 30ms, elastic concurrency, pay-per-request pricing
• Smart builds — content-addressed cache, remote build workers, automatic asset optimization, so builds get faster as you ship more

The platform also lists three regions with published health and latency figures: US-East (Ashburn, VA), EU-West (Paris, FR), and AP-South (Mumbai, IN).

How to decide if your project fits

Use these conditions to check your own case:

• Your code is in GitHub, GitLab, or Bitbucket → you can deploy directly.
• You use a major framework (Next.js, Svelte, Astro, Remix, Qwik) → build settings are auto-detected, no config needed.
• You use something else → you need a working Dockerfile.
• You need small server-side logic near users → use edge functions.
• You need a database → the platform's description mentions databases as part of the toolchain; check the current docs for supported options and setup before assuming a specific engine.
• You need to know the cost → Nept has a pricing page at nept.cloud/pricing; the site mentions pay-per-request pricing for serverless, but confirm current rates there rather than assuming a free tier.

If your project builds from a repo or a Dockerfile and you want push-to-deploy with previews and global edge delivery, Nept is designed for exactly that. If your app can't be built in a container or from a supported framework, or you need deployment methods outside Git-based flows, it won't fit.

Nept turns a Git push into a live, globally distributed deployment. Connect a repository (GitHub, GitLab, or Bitbucket), and every push triggers an automatic build that Nept optimizes and ships to edge nodes — no server configuration required. Each branch also gets its own preview URL so you can review changes before merging to production. This guide covers the four-step flow, what happens at each stage, and where things commonly go wrong.

The four-step deployment flow

Nept's own documentation describes the process as "from code to production in seconds," broken into four stages.

Step 1 — Push your code

Connect your Git repository to Nept. From that point on, every push to a tracked branch triggers an automatic build. The docs list GitHub, GitLab, and Bitbucket as supported sources.

git push origin main

Input: a commit pushed to a connected branch. Expected result: Nept detects the push and queues a build.

Step 2 — Auto-deploy (build and optimize)

Nept builds, optimizes, and deploys the app. The platform advertises "smart caching" — specifically a content-addressed cache and remote build workers — so repeat builds get faster as you ship more. The docs show a sample build completing in about 4.2 seconds, though real times depend on your project size and dependency graph.

Input: the pushed commit plus cached build artifacts from prior builds. Action: Nept runs the build, optimizes assets, and produces a deployable output. Expected result: a successful build ready to publish.

Step 3 — Go global instantly

Once built, the app goes live on Nept's edge network with zero extra configuration. Users are served from edge nodes close to them. Nept lists three regions with published health and latency figures:

Expected result: your app is reachable at a live URL (the docs show the pattern https://app.nept.cloud).

Step 4 — Preview and iterate

Every branch gets a unique preview URL. Share it with your team, collect feedback, and iterate before merging to production. The docs give the pattern:

preview: feat-xyz.app.nept.cloud

Expected result: a shareable staging URL per branch, isolated from production until you merge.

What Nept handles for you

The platform bundles several concerns that would otherwise need separate setup:

• Framework detection — auto-detected build settings for Next.js, Svelte, Astro, Remix, and Qwik. Custom Dockerfiles are supported for anything else.
• Edge functions — lightweight TypeScript functions deployed globally in one command, aimed at auth, personalization, A/B tests, and low-latency APIs.
• Security defaults — automatic TLS certificates on every domain, DDoS mitigation, and a WAF with managed rules, included rather than added on.
• Serverless scaling — cold starts under 30ms, elastic concurrency, and pay-per-request pricing, so traffic spikes don't require manual capacity changes.

Common sticking points

• Build failures block deployment. If Step 2 fails, nothing ships. Check the build log first — framework auto-detection usually works, but monorepos or unusual output directories may need a custom Dockerfile or adjusted settings.
• Preview URLs are per branch, not per commit. Pushing again to the same branch updates that branch's preview rather than creating a new one.
• Production is a merge decision. Previews are isolated; the live app updates when you merge to your production branch.
• Caching speeds up repeats, not first builds. The content-addressed cache helps most on subsequent deploys with similar dependencies.

When this workflow fits

Nept's push-to-deploy model suits teams that want Git as the single source of truth for releases, need per-branch previews for review, and prefer not to manage servers or edge configuration. If your project already builds cleanly in CI and you want global distribution without a DevOps layer, the four-step flow above is the entire workflow.