How Far AuthOS Got on One CPU and 1 GB of RAM
I rebuilt the AuthOS SQLite benchmark, untangled two limits outside the database, and measured its useful operating point inside a budget-shaped VM.

On this page
Audio edition
0:00 / 11:26
Ready
I wanted a practical number: how much AuthOS could a server costing less than $10 a month carry before latency turned bad?
I started on four pinned efficiency cores. At 6,000 constant k6 users, AuthOS completed a median 5,005 operations per second with no failed operations and a 781 ms p99. Raising the load to 10,000 users made it do less work—4,617 operations per second—while p99 climbed to 3.14 seconds. The service still returned the right responses, but it had crossed its capacity knee.
Then I moved the same build and workload into a KVM guest with one vCPU, 1 GiB of RAM, and a 25 GiB disk. Those are the dimensions of DigitalOcean’s $6 Basic Droplet as listed on 17 July 2026. A five-minute run at 2,000 users completed 592,497 operations with no failures, a 154 ms p99, and about 68% average guest CPU. On this smaller machine, the knee appeared between 4,000 and 5,000 users.
The previous version of this article lacked the exact k6 script, ramp schedule, seeded database, AuthOS revision, and raw output. I rebuilt the benchmark and kept those artifacts this time.
What I Tested
The system under test was the SQLite build of AuthOS , a Rust and Axum authentication service. The boundary was one release-mode API process, one SQLite database on local NVMe storage, and a local Mailpit instance for setup. The Vue clients, reverse proxy, TLS, network transit, and production email delivery were outside the test.
I recorded the main inputs:
| Component | Version or identity |
|---|---|
| AuthOS | commit 79e5a9440846f94dd31221c17b9b64930ec489bc |
| AuthOS binary | SHA-256 e3386a969271e4060f2ffdb2199e27b3276021b1cfa9be87f0787355c9ef884f |
| Rust | rustc 1.93.1 |
| k6 | v2.1.0 |
| Mailpit | v1.30.4 |
| Operating system | Ubuntu kernel 7.0.0-27-generic |
| Processor | Intel Core i7-1265U |
| Storage | Toshiba KBG30ZMV512G NVMe, ext4 |
I built the server from the pinned commit with:
cargo build --release --locked --bin sso_sqlite
The machine has 10 physical cores and 12 logical CPUs. I pinned AuthOS to logical CPUs 4–7, four distinct efficiency cores according to lscpu, and k6 to the remaining CPUs. The CPU governor was performance; SQLite used at most 10 pooled connections. The API had no memory cap, so I sampled its resident memory.
Running the load generator and server on one host removed internet latency but allowed CPU, cache, power, thermal, and storage interference. The later VM run separated the load generator from the guest, though both still used the same physical machine.
Rebuilding the Workload
The only surviving workload description from the old test was a 70/20/10 mix. I reconstructed it as business operations:
- 70% authenticated
GET /api/subscription - 20% OAuth device operations, each consisting of
POST /auth/device/codefollowed byPOST /auth/token - 10% authenticated
GET /api/user
A device operation creates a code and immediately polls it once. The correct poll result is HTTP 400 with DEVICE_CODE_PENDING, because nobody completes the browser authorization during the synthetic test. k6 treats that specific response as expected. Every other status or error code fails the operation.
Because a device operation makes two requests, the 70/20/10 ratio describes operations rather than HTTP requests. I report both rates in the results.
Each virtual user performs one operation, waits one second, and repeats. The random generator is seeded per VU. Every measured point uses constant-vus for 60 seconds with up to 30 seconds of graceful shutdown. The success thresholds are an operation failure rate below 1% and aggregate p99 below 30 seconds.
The database snapshot contains two users, one active organization, one service, and the session required for the scoped benchmark user. Before each trial I restored that same snapshot, started AuthOS, waited for /health/ready, then started k6. Device-code rows accumulated only within that trial.
Throughout this article, “10,000 users” means 10,000 k6 VUs running this loop—not 10,000 real people or 10,000 simultaneous HTTP requests.
The First Wall Was a Rate Limiter
My first unsharded 6,000-user run failed 11.69% of its operations. A repeat failed 11.71%. It looked like a clean breaking point until I classified the responses: every failure was an HTTP 429 from a device route.
At this AuthOS revision, DISABLE_RATE_LIMITING=true does not remove the Governor layer. It configures the device routes for 1,000 requests per second with a burst of 10,000 per client IP. k6 sent every request from 127.0.0.1, so the synthetic client topology exhausted that per-IP bucket.
SQLite had not failed; the shared per-IP bucket had. I kept the AuthOS binary unchanged, distributed the VUs across 127.0.0.2 through 127.0.0.254 with k6’s --local-ips option, and reran the test. The same 6,000-user workload completed with no failures. The two false starts remain in the raw archive.
Where Four Cores Bent
The 100-, 1,000-, and 3,000-user rows are one trial each. The 6,000- and 10,000-user rows are the median of three independent trials. Latencies are aggregate HTTP request latencies.
| VUs | Operations/s | HTTP requests/s | p50 | p95 | p99 | Operation failures | Average API RSS |
|---|---|---|---|---|---|---|---|
| 100 | 99.5 | 119.4 | 1.15 ms | 6.24 ms | 24.1 ms | 0% | 34 MiB |
| 1,000 | 987 | 1,185 | 1.05 ms | 31.8 ms | 101 ms | 0% | 103 MiB |
| 3,000 | 2,922 | 3,507 | 1.11 ms | 83.2 ms | 278 ms | 0% | 255 MiB |
| 6,000 | 5,005 | 6,004 | 82.6 ms | 583 ms | 781 ms | 0% | 491 MiB |
| 10,000 | 4,617 | 5,540 | 944 ms | 2.13 s | 3.14 s | 0% | 796 MiB |
Across the repeated trials, the 6,000-user point remained faster and steadier:
| VUs | Operations/s range | p99 range | Average CPU range | Peak RSS range |
|---|---|---|---|---|
| 6,000 | 4,739–5,247 | 686–964 ms | 2.94–3.16 cores | 503–506 MiB |
| 10,000 | 4,471–4,824 | 2.89–3.15 s | 3.38–3.40 cores | 815–837 MiB |
The throughput reversal marks saturation: 10,000 users completed less work than 6,000 while waiting much longer. The API used most, but not all, of its four pinned CPUs; NVMe writes were bursty around the WAL; and RSS remained below 1 GiB. Isolating the cause would require queue depth, SQLite busy time, checkpoint timing, request traces, scheduler data, and storage latency that I did not collect.
One CPU and 1 GiB
On 17 July 2026, DigitalOcean listed a Basic Droplet with one shared vCPU, 1 GiB RAM, and 25 GiB SSD storage at $6 per month. I reproduced that resource shape in a fresh Ubuntu 26.04 KVM guest:
| Component | Budget-VM configuration |
|---|---|
| AuthOS | Same commit and binary used above |
| Hypervisor | QEMU 10.2.1 with KVM |
| Guest CPU | One vCPU exposing one i7-1265U hardware thread |
| Guest memory | 1,024 MiB assigned; 956 MiB visible to Linux |
| Guest disk | 25 GiB virtio qcow2, ext4 |
| Guest operating system | Ubuntu 26.04 LTS, kernel 7.0.0-27-generic |
| Network | Direct virtio TAP; load generator remained outside the guest |
| Idle host-to-guest ping | 0.267 ms average |
| AuthOS file-descriptor limit | 65,535 |
The VM borrowed the plan’s dimensions, not its hardware. It still ran on my i7-1265U and local NVMe, without the provider’s shared-CPU scheduler, storage, network transit, regional latency, or noisy neighbours. I used the price only to choose a plausible sub-$10 resource envelope.
I used the same 70/20/10 operation mix, one-second think time, seeded database, and success checks as the four-core experiment. AuthOS was restarted from the same snapshot before every trial. The load generator used 91 local source addresses at the repeated high-load points so the device-flow governor saw independent clients instead of one synthetic NAT address.
The 3,000- and 4,000-user rows are medians of three 60-second trials. Other rows are one trial. Latencies remain aggregate HTTP latencies.
| VUs | Operations/s | HTTP requests/s | p50 | p95 | p99 | Failures | Guest CPU | Peak AuthOS RSS |
|---|---|---|---|---|---|---|---|---|
| 100 | 99 | 119 | 1.13 ms | 7.21 ms | 85.2 ms | 0% | 3% | 42 MiB |
| 500 | 493 | 592 | 1.21 ms | 40.2 ms | 131 ms | 0% | 16% | 68 MiB |
| 1,000 | 977 | 1,173 | 1.10 ms | 68.6 ms | 195 ms | 0% | 30% | 106 MiB |
| 2,000 | 1,917 | 2,302 | 2.34 ms | 192 ms | 350 ms | 0% | 60% | 184 MiB |
| 3,000 | 2,588 | 3,105 | 76.9 ms | 384 ms | 603 ms | 0% | 86% | 262 MiB |
| 4,000 | 2,737 | 3,283 | 326 ms | 781 ms | 1.09 s | 0% | 94% | 344 MiB |
| 5,000 | 2,709 | 3,250 | 621 ms | 1.45 s | 1.99 s | 0% | 94% | 428 MiB |
The three 3,000-user trials ranged from 2,564 to 2,602 operations per second, with p99 between 573 and 606 ms. At 4,000 users, the range widened to 2,648–2,863 operations per second and 945–1,162 ms p99. At 5,000 users, throughput fell below the 4,000-user median while latency nearly doubled. That is the small VM’s capacity knee for this workload.
To see whether the short trials flattered the VM, I added five-minute runs at 2,000 and 3,000 users:
| Soak point | Completed operations | Operations/s | HTTP requests/s | p99 | Failures | Guest CPU | Peak AuthOS RSS |
|---|---|---|---|---|---|---|---|
| 2,000 VUs for 5 min | 592,497 | 1,968 | 2,361 | 154 ms | 0% | 68% | 196 MiB |
| 3,000 VUs for 5 min | 755,017 | 2,506 | 3,007 | 1.06 s | 0% | 95% | 277 MiB |
At 2,000 users, latency and CPU still had room: RSS reached roughly 180 MiB in the first minute and stayed near it. At 3,000, CPU averaged 95% and p99 crossed one second as the database grew to 150,511 device-code rows. I would treat 3,000 as a demonstrated burst, not a sustained target.
Two Limits Arrived Before CPU Saturation
The first 1,000-user attempt failed 7.09% of operations while the guest was only about 31% busy. AuthOS logged Too many open files: the interactive shell had given it a soft limit of 1,024 descriptors. With the limit raised to 65,535, the same case completed with no failures. A high-concurrency systemd deployment needs an explicit limit such as LimitNOFILE=65535.
At 4,000 users, an unsharded diagnostic failed 0.70% of operations. Every failure was an HTTP 429 from a device route. The single generator IP was making both device-code and token-poll requests, crossing that client’s governor budget. Distributing the synthetic users over the local address pool removed the 429s without changing the AuthOS binary. Both diagnostics remain in the evidence archive.
The Useful Number
The five-minute 2,000-user run is the useful operating reference for this VM: 1,968 operations per second, 2,361 HTTP requests per second, a 154 ms p99, no failures, and 68% average CPU. It leaves enough room for variation without pretending that the highest VU count is the best place to operate.
Before putting real users on this setup, I would repeat the run on the actual provider with TLS, a reverse proxy, internet latency, password-hash bursts, backups, key rotation, upgrades, and host-failure recovery in view. Within the workload I measured, SQLite gives me no performance reason to split the AuthOS monolith yet.
In the platform follow-up, I use the budget VM’s sustained operation rate to build a clearly labelled 500,000-MAU capacity model with explicit activity and peak-traffic assumptions.
Reproduce the Runs
The four-core benchmark directory contains its exact k6 script, build and run commands, pinned versions, checksums, selected-trial CSV, and raw archive. The budget-VM benchmark directory contains its cloud-init configuration, guest and host runners, aggregate CSV, diagnostics, telemetry, and raw result archive.
The public AuthOS repository also carries the budget-VM harness beside the code it measures.



