Real Go benchmark numbers comparing ALOS DB against MongoDB, PostgreSQL, and ScyllaDB. All tests containerized in Docker (Debian 13), run over TCP with encryption enabled — no embedded shortcuts.
These benchmarks test ALOS DB in Remote Mode — full client-server over TCP with AES-256-GCM encryption, MessagePack serialization, connection pooling, and network round-trips on every operation. This is the slowest mode ALOS DB can run in, with the most overhead, because every request travels over the network, gets encrypted/decrypted, serialized/deserialized, and routed through the server’s worker pool. Despite all of that overhead, ALOS DB still dominates every competitor across the board.
Remote Mode = real client-server over TCP. When you use ALOS DB in embedded/local mode (same process, no network), it runs 10–50x faster than the numbers shown here. For example, InsertOne drops to 446 ns (2.2M ops/sec) and FindByID drops to 149 ns (6.7M ops/sec). See the Embedded Mode section below for full local numbers. Also the reason FindOne can seem slower is that all other operations only wait for the acknowledgment packet, whereas FindOne waits for the actual data.
| CPU | AMD Ryzen 7 5700X — 8 cores / 16 threads @ 3.4 GHz (boost 4.6 GHz) |
|---|---|
| OS | Debian 13 (Trixie) Docker containers, all databases on same host |
| Go Version | Go 1.26, go test -bench, -benchmem, -benchtime=2s, -count=3 |
| Parallelism | GOMAXPROCS=16 (all benchmarks run with RunParallel) |
| ALOS DB | Remote Mode — client-server over TCP, AES-256-GCM encryption, MessagePack wire protocol, connection pool. This is the slowest mode with full network + encryption overhead. |
| MongoDB | mongo:7 Docker container, localhost:27017, Go driver v2 |
| PostgreSQL | postgres:16 Docker container, localhost:5432, pgx/v5 driver, 100 pool conns |
| ScyllaDB | scylladb/scylla:latest Docker (--smp 2), localhost:9042, gocql driver |
All databases auto-index their primary key. ALOS DB also auto-indexes every field — no manual index creation needed. Every benchmark uses identical test documents with the same fields and data patterns.
Each operation benchmarked individually with b.RunParallel across 16 threads.
Numbers show best of 3 runs (lowest ns/op).
| Operation | ALOS DB | MongoDB | PostgreSQL | ScyllaDB |
|---|---|---|---|---|
| InsertOne | 14,266 ns 70K ops/sec |
44,317 ns 22.6K ops/sec |
76,531 ns 13.1K ops/sec |
94,343 ns 10.6K ops/sec |
| FindOne | 11,095 ns 90K ops/sec |
36,302 ns 27.5K ops/sec |
52,457 ns 19.1K ops/sec |
88,131 ns 11.3K ops/sec |
| UpdateOne | 18,252 ns 55K ops/sec |
38,384 ns 26.1K ops/sec |
90,411 ns 11.1K ops/sec |
90,409 ns 11.1K ops/sec |
| DeleteOne | 20,352 ns 49K ops/sec |
228,786 ns 4.4K ops/sec |
854,960 ns 1.2K ops/sec |
1,513,814 ns 661 ops/sec |
| UpsertOne | 19,583 ns 51K ops/sec |
35,928 ns 27.8K ops/sec |
91,314 ns 11.0K ops/sec |
90,703 ns 11.0K ops/sec |
| Operation | vs MongoDB | vs PostgreSQL | vs ScyllaDB |
|---|---|---|---|
| InsertOne | 3.1x faster | 5.4x faster | 6.6x faster |
| FindOne | 3.3x faster | 4.7x faster | 8.0x faster |
| UpdateOne | 2.1x faster | 5.0x faster | 5.0x faster |
| DeleteOne | 11.2x faster | 41.8x faster | 131.5x faster |
| UpsertOne | 6.6x faster | 16.8x faster | 16.7x faster |
Bar length represents throughput (ops/sec). Longer is better.
Batch operations processing 100 documents per call. FindMany queries return all matching documents in a range scan.
| Operation | ALOS DB | MongoDB | PostgreSQL | ScyllaDB |
|---|---|---|---|---|
| InsertMany (50 docs) |
91,258 ns 548K docs/sec |
1,275,619 ns 78.4K docs/sec |
2,127,625 ns 47.0K docs/sec |
2,275,957 ns 43.9K docs/sec |
| FindMany (~128 docs) |
358,269 ns 357K docs/sec |
356,466 ns 2,805 q/sec |
1,089,512 ns 918 q/sec |
1,445,828 ns 691 q/sec |
| UpdateMany (~128 docs) |
1,564,945 ns 82K docs/sec |
19,229,270 ns 52 ops/sec |
299,731 ns 3.3K ops/sec |
N/A |
| DeleteMany (~128 docs) |
722,335 ns 177K docs/sec |
34,346 ns 29.1K ops/sec |
17,328 ns 57.7K ops/sec |
89,329 ns 11.2K ops/sec |
| UpsertMany (~128 docs) |
814,067 ns 157K docs/sec |
42,170 ns 23.7K ops/sec |
91,139 ns 11.0K ops/sec |
N/A |
| Operation | vs MongoDB | vs PostgreSQL | vs ScyllaDB |
|---|---|---|---|
| InsertMany | 7.0x faster | 11.7x faster | 12.5x faster |
| FindMany | 127x docs/sec | 389x docs/sec | 517x docs/sec |
| UpdateMany | 1,577x docs/sec | 25x docs/sec | — |
| DeleteMany | 6.1x docs/sec | 3.1x docs/sec | 15.8x docs/sec |
| UpsertMany | 6.6x docs/sec | 14.3x docs/sec | — |
FindMany (range query) returns all documents matching
{"age": {"$gte": 20, "$lte": 40}} from a seeded dataset. ALOS DB fully
serializes, encrypts, transmits, decrypts, and deserializes every matching document
(~210 docs) in a single response — matching MongoDB at near-parity latency, even
though MongoDB only returns a lazy cursor reference without decoding any documents.
Complete benchmark data. Best run (lowest latency) from 3 runs shown. All tests used
b.RunParallel with GOMAXPROCS=16.
| Operation | ns/op | ops/sec | B/op | allocs/op |
|---|---|---|---|---|
| InsertOne | 14,266 | 70,099 | - | - |
| InsertMany (50) | 91,258 | 10,958 ops/s (548K docs/s) | - | - |
| FindOne | 11,095 | 90,129 | - | - |
| FindMany (~128 docs) | 358,269 | 2,791 ops/s (357K docs/s) | - | - |
| UpdateOne | 18,252 | 54,789 | - | - |
| UpdateMany (~128 docs) | 1,564,945 | 639 ops/s (82K docs/s) | - | - |
| DeleteOne | 20,352 | 49,136 | - | - |
| DeleteMany (~128 docs) | 722,335 | 1,384 ops/s (177K docs/s) | - | - |
| UpsertOne | 19,583 | 51,065 | - | - |
| UpsertMany (~128 docs) | 814,067 | 1,228 ops/s (157K docs/s) | - | - |
| Count | 62,720 | 15,944 | - | - |
| Aggregate | 28,930 | 34,566 | - | - |
| Operation | ns/op | ops/sec | B/op | allocs/op |
|---|---|---|---|---|
| InsertOne | 44,317 | 22,565 | 12,093 | 128 |
| InsertMany (100) | 1,275,619 | 78,394 docs/s | 679,900 | 5,951 |
| FindOne | 36,302 | 27,546 | 7,555 | 75 |
| FindMany (range) | 356,466 | 2,805 | 23,823 | 79 |
| UpdateOne | 38,384 | 26,052 | 7,547 | 102 |
| UpdateMany | 19,229,270 | 52 | 7,947 | 110 |
| DeleteOne | 228,786 | 4,371 | 5,021 | 70 |
| DeleteMany | 34,346 | 29,116 | 5,547 | 72 |
| UpsertOne | 35,928 | 27,834 | 7,660 | 106 |
| UpsertMany | 42,170 | 23,714 | 7,858 | 106 |
| Operation | ns/op | ops/sec | B/op | allocs/op |
|---|---|---|---|---|
| InsertOne | 76,531 | 13,066 | 2,622 | 61 |
| InsertMany (100) | 2,127,625 | 47,002 docs/s | 200,564 | 2,528 |
| FindOne | 52,457 | 19,063 | 1,785 | 44 |
| FindMany (range) | 1,089,512 | 918 | 318,260 | 14,971 |
| UpdateOne | 90,411 | 11,061 | 234 | 7 |
| UpdateMany | 299,731 | 3,337 | 1,330 | 28 |
| DeleteOne | 854,960 | 1,170 | 204 | 6 |
| DeleteMany | 17,328 | 57,709 | 179 | 5 |
| UpsertOne | 91,314 | 10,951 | 452 | 14 |
| UpsertMany | 91,139 | 10,972 | 448 | 14 |
| Operation | ns/op | ops/sec | B/op | allocs/op |
|---|---|---|---|---|
| InsertOne | 94,343 | 10,600 | 1,476 | 26 |
| InsertMany (100) | 2,275,957 | 43,937 docs/s | 397,117 | 6,038 |
| FindOne | 88,131 | 11,347 | 1,492 | 26 |
| FindMany (range) | 1,445,828 | 691 | 3,220 | 47 |
| UpdateOne | 90,409 | 11,061 | 1,275 | 20 |
| DeleteOne | 1,513,814 | 661 | 2,966 | 43 |
| DeleteMany | 89,329 | 11,195 | 1,259 | 19 |
| UpsertOne | 90,703 | 11,025 | 1,483 | 24 |
When you embed ALOS DB directly in your Go application (same process, no TCP, no encryption), you skip all network overhead and get 10–50x faster performance. These numbers show what ALOS DB can do when the bottleneck isn’t the network.
Embedded mode is ALOS DB’s fastest mode. No TCP sockets, no AES-256-GCM encryption, no MessagePack serialization, no connection pool, no worker dispatch. Just direct function calls to the storage engine. Use this when your application and database run on the same machine.
| Operation | ns/op | ops/sec | B/op | allocs/op | vs Remote |
|---|---|---|---|---|---|
| InsertOne | 446 | 2,242,152 | 693 | 16 | 9.7x faster |
| InsertMany (100) | 109,006 | 917,376 docs/s | 73,396 | 1,606 | 1.3x faster |
| FindByID | 149 | 6,711,409 | 352 | 3 | 45x faster |
| FindByIndex | 211 | 4,739,336 | 391 | 5 | 32x faster |
| FindMany (range) | 165,891 | 6,028 | 363,611 | 2,126 | 1.6x faster |
| UpdateOne | 239 | 4,184,100 | 456 | 6 | 23x faster |
| DeleteOne | 1,108 | 902,527 | 92 | 3 | 10.4x faster |
Embedded mode uses the exact same storage engine, B-tree indexes, and MVCC transactions as remote mode. The only difference is removing the network stack. All ACID guarantees, auto-indexing, and durability remain identical.