v0.1.2 · Self-hosted · Open Source

Network Diagnosis
for your own server

FluxTest is a self-hosted network diagnosis tool that measures latency, download, and upload throughput between a browser and your infrastructure — not a third-party CDN.

View on GitHub Quick Start
Server my-homelab-01
Status Online
Latency 4 ms
Jitter 1.2 ms
Bloat +3 ms
Download
102 Mbps
Elapsed
00:15
Downloaded
66 MB
Upload
45 Mbps
Elapsed
00:15
Uploaded
24 MB
Test Complete
Connection Analysis
Save Report
90 /100
A - Exceptional
Overall Score
Latency Excellent — 4 ms

Exceptional TTFB. Ideal for latency-sensitive APIs and real-time dashboards.

Jitter Stable — 0.2 ms

Highly consistent response times. Reliable for WebSocket connections, real-time collaboration features.

Download Excellent — 102 Mbps

Ample ingress. Static assets and streaming payloads served without bottleneck.

Upload Good — 45 Mbps

Sufficient egress for most workloads. Monitor under concurrent heavy upload.

🫧
Bloat Minimal — +3 ms

Negligible latency increase under load. Your network has proper queue management.

What it does

Built for real infrastructure

Everything you need to accurately measure network performance between your client and your own server.

Real-Time Progress

Live speed rings, Mbps readout, elapsed timer, and byte counter updating at the display's native frame rate.

Latency, Jitter & Bloat

5 sequential pings compute average RTT and jitter (stddev). During download, concurrent pings detect bufferbloat — exposing connection stability under load.

Self-Hosted

Test against your own VPS, home-lab, edge node, or bare-metal server — not a third-party CDN.

Docker-Ready

Pre-built image on GHCR. One docker compose up command to deploy with Gunicorn and Traefik labels.

Secure by Design

Streaming chunks prevent memory exhaustion. Server-side upload ceiling stops runaway workers. Cache-control on all data endpoints.

Connection Analysis & Report

After every test, an A–F network score and per-metric diagnosis with actionable insights. Hit Save Report to export a ready to attach to a ticket or document a baseline.

Under the hood

How a test works

1

Latency & Jitter Probe

Five /ping requests are fired sequentially. Average RTT is your latency; the standard deviation across those five samples is your jitter.

2

Download + Bloat Probe (15 s)

The server streams 1 MB random chunks. The browser reads the stream and computes live speed. Concurrently, periodic /bloat pings measure latency under load to detect bufferbloat.

3

Upload (15 s)

The browser generates random 64 KB chunks via ReadableStream for 15 s, then closes. The server counts received bytes and returns the result.

4

Report

Every metric is scored A–F and accompanied by a production-focused recommendation. Hit Save Report to export a branded PNG you can share or archive.

Full test completes in ~35 s regardless of connection speed
Deploy

Up in seconds

No configuration files to edit. One command and you're testing.

Option A — Docker Compose
docker-compose.yml
services:
  speedtest:
    image: ghcr.io/siddheshgunjal/flux-test:latest
    container_name: flux-test
    ports:
      - "4855:4855"
    environment:
      - SERVER_NAME=${HOSTNAME:-my-server}
    restart: unless-stopped
    deploy:
        resources:
            reservations:
                memory: 256M
                cpus: 0.5
    labels:
        - "traefik.enable=true"
        - "traefik.http.routers.speedtest.rule=Host(`speedtest.example.com`)"
        - "traefik.http.routers.speedtest.entrypoints=websecure"
        - "traefik.http.routers.speedtest.tls.certresolver=letsencrypt"
terminal
# start
docker compose up -d

# stop
docker compose down
Option B — Docker run
terminal
docker run --rm \
  -p 4855:4855 \
  -e SERVER_NAME=${HOSTNAME} \
  ghcr.io/siddheshgunjal/flux-test:latest

Access the UI at http://your-server-ip:4855. For HTTPS, place it behind a reverse proxy such as Traefik or Nginx with TLS termination.

Intended Use

Not just another speed test

What it's great for

  • · Validating client-to-server throughput on your home lab
  • · Testing VPS network performance after provisioning
  • · Diagnosing bandwidth bottlenecks on Tunnels or Proxies
  • · Checking edge node connectivity in private clouds
  • · Verifying network after Docker/K8s deployments
  • · Getting a connection score with per-metric production recommendations
  • · Exporting a report card to document and share network baselines

What it's not

  • · A public ISP speed benchmark (no geographically distributed nodes)
  • · A replacement for Speedtest.net or fast.com
  • · Designed to be exposed publicly on the internet
  • · A synthetic traffic generator for load testing or benchmarking
Built with
Python Docker React Tailwind CSS
FluxTest

Ready to test your own server?

Deploy in one command. No accounts, no data sent to third parties.