diff --git a/frameworks/hyper-express/README.md b/frameworks/hyper-express/README.md
index 435e7fe77..6a72a8483 100644
--- a/frameworks/hyper-express/README.md
+++ b/frameworks/hyper-express/README.md
@@ -15,6 +15,12 @@ An Express-like API on uWebSockets.js, with the cluster module for multi-core sc
 |----------|--------|-------------|
 | `/pipeline` | GET | Returns `ok` (plain text) |
 | `/baseline11` | GET/POST | Sums query parameter values, plus the body for POST |
+| `/baseline2` | GET | Sums query parameter values |
+| `/async-db` | GET | Reads from PostgreSQL through a pool of four |
+| `/static/:filename` | GET | Serves a file from disk, the brotli or gzip variant when the client accepts one |
+| `/crud/items` | GET/POST | Lists items by category with paging, or inserts one |
+| `/crud/items/:id` | GET/PUT | Reads one item through a Redis cache-aside, or updates it and drops the cached copy |
+| `/fortunes` | GET | Reads 200 rows from PostgreSQL, appends the runtime row, sorts and renders the HTML table |
 | `/json/:count` | GET | Serializes a slice of the dataset, gzip or brotli when the client accepts one |
 | `/upload` | POST | Counts the bytes of the request body |
 
@@ -36,3 +42,15 @@ than where it looks the same:
 
 Every worker binds `:8080` on its own: uWebSockets.js shares the port across processes unless
 `exclusive_port` is asked for, so the cluster fork per core needs nothing else.
+
+`json-tls` and `static-tls` listen on `8081` when `/certs/server.crt` and `/certs/server.key` are
+mounted. hyper-express takes TLS material through the uWS options at construction rather than
+through a separate `https` server, so the port is a second `Server` carrying the same routes.
+Every worker in the cluster binds it, exactly as they all bind `8080`.
+
+Static file bodies are read from disk on every request, per the arena rules: only the list of
+names, existing pre-compressed variants and content types is scanned at startup.
+
+`fortunes` is rendered by hand rather than through a template engine, which tuned mode allows;
+the handler still queries per request, appends the runtime row, sorts and escapes `<`, `>`, `&`,
+`"` and `'`.
diff --git a/frameworks/hyper-express/app.js b/frameworks/hyper-express/app.js
index ead9e5d0f..f236593ca 100644
--- a/frameworks/hyper-express/app.js
+++ b/frameworks/hyper-express/app.js
@@ -24,11 +24,6 @@ if (cluster.isPrimary) {
     // enough that a higher level buys bytes nobody counts
     const GZIP_OPTS = { level: 1 };
 
-    // max_body_length defaults to 250 KB and answers 413 above it, so the upload profile,
-    // which posts up to 20 MB, needs the cap raised. Every worker binds :8080 on its own:
-    // uWebSockets.js shares the port between processes unless exclusive_port is asked for.
-    const server = new Server({ max_body_length: 32 * 1024 * 1024 });
-
     const SERVER_HDR = 'hyper-express';
 
     // Dataset
@@ -37,6 +32,51 @@ if (cluster.isPrimary) {
         datasetItems = JSON.parse(fs.readFileSync(process.env.DATASET_PATH || '/data/dataset.json', 'utf8'));
     } catch (e) {}
 
+    // PostgreSQL, for async-db, api-4/api-16, crud and fortunes. The pool is per worker
+    // and this entry forks one per core, so the harness's budget is split across them
+    // rather than opened by each.
+    let pgPool;
+    if (process.env.DATABASE_URL) {
+        try {
+            const { Pool } = require('pg');
+            pgPool = new Pool({ connectionString: process.env.DATABASE_URL, max: 4 });
+            pgPool.on('error', () => {});
+        } catch (e) {}
+    }
+
+    // Redis, for the crud cache-aside only. One connection per worker, so the cache is
+    // shared across the cluster where a per-worker map would not be.
+    let redis;
+    if (process.env.REDIS_URL) {
+        try {
+            const Redis = require('ioredis');
+            redis = new Redis(process.env.REDIS_URL, { enableAutoPipelining: true });
+            redis.on('error', () => {});
+        } catch (e) {}
+    }
+
+    const MIME_TYPES = {
+        '.css': 'text/css', '.js': 'application/javascript', '.html': 'text/html',
+        '.woff2': 'font/woff2', '.svg': 'image/svg+xml', '.webp': 'image/webp', '.json': 'application/json',
+    };
+
+    // No file data lives in memory, per the arena rules: this scans names only, so a request
+    // knows which pre-compressed variants exist and the content type. The bytes are read from
+    // disk on every request.
+    const staticFiles = {};
+    try {
+        for (const name of fs.readdirSync('/data/static')) {
+            if (name.endsWith('.br') || name.endsWith('.gz')) continue;
+            const ext = name.slice(name.lastIndexOf('.'));
+            staticFiles[name] = {
+                path: `/data/static/${name}`,
+                br: fs.existsSync(`/data/static/${name}.br`),
+                gz: fs.existsSync(`/data/static/${name}.gz`),
+                ct: MIME_TYPES[ext] || 'application/octet-stream'
+            };
+        }
+    } catch (e) {}
+
     function sumQuery(query) {
         let sum = 0;
         for (const k in query) {
@@ -46,59 +86,262 @@ if (cluster.isPrimary) {
         return sum;
     }
 
-    server.get('/pipeline', (request, response) => {
-        response.header('server', SERVER_HDR).type('text/plain').send('ok');
+    const ITEM_COLUMNS =
+        'id, name, category, price, quantity, active, tags, rating_score, rating_count';
+    const itemShape = (r) => ({
+        id: r.id, name: r.name, category: r.category, price: r.price,
+        quantity: r.quantity, active: r.active, tags: r.tags,
+        rating: { score: r.rating_score, count: r.rating_count }
     });
 
-    server.get('/json/:count', (request, response) => {
-        let count = parseInt(request.path_parameters.count, 10) || 0;
-        if (count < 0) count = 0;
-        if (count > datasetItems.length) count = datasetItems.length;
-        const m = parseInt(request.query_parameters.m, 10) || 1;
-        const items = datasetItems.slice(0, count).map(d => ({
-            id: d.id, name: d.name, category: d.category,
-            price: d.price, quantity: d.quantity, active: d.active,
-            tags: d.tags, rating: d.rating,
-            total: d.price * d.quantity * m
-        }));
-        const body = JSON.stringify({ items, count });
-        // json-comp profile: negotiated per request. hyper-express ships no response
-        // compression of its own, so the encoding is picked here and nothing is sent
-        // compressed without Accept-Encoding.
-        const ae = request.headers['accept-encoding'] || '';
-        if (ae.includes('gzip')) {
-            response.header('server', SERVER_HDR)
-                .header('content-encoding', 'gzip')
-                .type('application/json')
-                .send(zlib.gzipSync(body, GZIP_OPTS));
-        } else if (ae.includes('br')) {
-            response.header('server', SERVER_HDR)
-                .header('content-encoding', 'br')
-                .type('application/json')
-                .send(zlib.brotliCompressSync(body, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 3 } }));
-        } else {
-            response.header('server', SERVER_HDR).type('application/json').send(body);
-        }
-    });
+    function sendJson(response, body, status = 200, extra = null) {
+        response.status(status).header('server', SERVER_HDR).type('application/json');
+        if (extra) for (const k in extra) response.header(k, extra[k]);
+        response.send(body);
+    }
+    const dbError = (response, msg, status = 500) => sendJson(response, `{"error":"${msg}"}`, status);
+
+    // The profile reads and writes the same ids, so a long TTL would answer from a copy
+    // the writes have already moved past.
+    const CRUD_TTL_MS = 200;
+
+    // ── fortunes ────────────────────────────────────────────────────────────────
+    // Tuned mode, so the page is emitted by hand rather than through an engine. Row 11
+    // of the seed carries a <script> tag and it has to leave here as text.
+    const RUNTIME_FORTUNE = 'Additional fortune added at request time.';
+    const ESCAPE = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
+    const escapeHtml = (s) => s.replace(/[&<>"']/g, c => ESCAPE[c]);
+
+    async function readJson(request) {
+        try { return JSON.parse(await request.text()); } catch (e) { return null; }
+    }
 
-    // The request is a lazy Readable: counting bytes never needs the 20 MB body in memory,
-    // which is what request.buffer() would cost
-    server.post('/upload', (request, response) => {
-        let size = 0;
-        request.on('data', chunk => size += chunk.length);
-        request.on('end', () => {
-            response.header('server', SERVER_HDR).type('text/plain').send(String(size));
+    function registerRoutes(server) {
+        server.get('/pipeline', (request, response) => {
+            response.header('server', SERVER_HDR).type('text/plain').send('ok');
         });
-    });
 
-    server.any('/baseline11', async (request, response) => {
-        let total = sumQuery(request.query_parameters);
-        if (request.method === 'POST') {
-            const n = parseInt((await request.text()).trim(), 10);
-            if (n === n) total += n;
-        }
-        response.header('server', SERVER_HDR).type('text/plain').send(String(total));
-    });
+        server.get('/json/:count', (request, response) => {
+            let count = parseInt(request.path_parameters.count, 10) || 0;
+            if (count < 0) count = 0;
+            if (count > datasetItems.length) count = datasetItems.length;
+            const m = parseInt(request.query_parameters.m, 10) || 1;
+            const items = datasetItems.slice(0, count).map(d => ({
+                id: d.id, name: d.name, category: d.category,
+                price: d.price, quantity: d.quantity, active: d.active,
+                tags: d.tags, rating: d.rating,
+                total: d.price * d.quantity * m
+            }));
+            const body = JSON.stringify({ items, count });
+            // json-comp profile: negotiated per request. hyper-express ships no response
+            // compression of its own, so the encoding is picked here and nothing is sent
+            // compressed without Accept-Encoding.
+            const ae = request.headers['accept-encoding'] || '';
+            if (ae.includes('gzip')) {
+                response.header('server', SERVER_HDR)
+                    .header('content-encoding', 'gzip')
+                    .type('application/json')
+                    .send(zlib.gzipSync(body, GZIP_OPTS));
+            } else if (ae.includes('br')) {
+                response.header('server', SERVER_HDR)
+                    .header('content-encoding', 'br')
+                    .type('application/json')
+                    .send(zlib.brotliCompressSync(body, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 3 } }));
+            } else {
+                response.header('server', SERVER_HDR).type('application/json').send(body);
+            }
+        });
+
+        server.get('/async-db', async (request, response) => {
+            if (!pgPool) {
+                return response.header('server', SERVER_HDR).type('application/json').send('{"items":[],"count":0}');
+            }
+            const q = request.query_parameters;
+            const min = parseInt(q.min, 10) || 10;
+            const max = parseInt(q.max, 10) || 50;
+            let limit = parseInt(q.limit, 10) || 50;
+            if (limit < 1) limit = 1;
+            if (limit > 50) limit = 50;
+            try {
+                const r = await pgPool.query({
+                    name: 'async-db',
+                    text: `SELECT ${ITEM_COLUMNS} FROM items WHERE price BETWEEN $1 AND $2 LIMIT $3`,
+                    values: [min, max, limit]
+                });
+                const items = r.rows.map(itemShape);
+                sendJson(response, JSON.stringify({ items, count: items.length }));
+            } catch (e) {
+                response.header('server', SERVER_HDR).type('application/json').send('{"items":[],"count":0}');
+            }
+        });
 
-    server.listen(8080);
+        // ── crud ────────────────────────────────────────────────────────────────
+        server.get('/crud/items', async (request, response) => {
+            if (!pgPool) return dbError(response, 'DB not available');
+            const q = request.query_parameters;
+            const category = q.category || 'electronics';
+            const page = Math.max(1, parseInt(q.page, 10) || 1);
+            let limit = parseInt(q.limit, 10) || 10;
+            if (limit < 1) limit = 1;
+            if (limit > 50) limit = 50;
+            try {
+                const r = await pgPool.query({
+                    name: 'crud-list',
+                    text: `SELECT ${ITEM_COLUMNS} FROM items WHERE category = $1 ORDER BY id LIMIT $2 OFFSET $3`,
+                    values: [category, limit, (page - 1) * limit]
+                });
+                const items = r.rows.map(itemShape);
+                sendJson(response, JSON.stringify({ items, total: items.length, page, limit }));
+            } catch (e) { dbError(response, 'query failed'); }
+        });
+
+        server.post('/crud/items', async (request, response) => {
+            if (!pgPool) return dbError(response, 'DB not available');
+            const b = await readJson(request);
+            if (!b) return dbError(response, 'insert failed');
+            try {
+                const r = await pgPool.query({
+                    name: 'crud-create',
+                    text: 'INSERT INTO items (id, name, category, price, quantity, active, tags, rating_score, rating_count) ' +
+                        'VALUES ($1, $2, $3, $4, $5, true, \'["bench"]\', 0, 0) ' +
+                        'ON CONFLICT (id) DO UPDATE SET name = $2, price = $4, quantity = $5 RETURNING id',
+                    values: [b.id, b.name ?? 'New Product', b.category ?? 'test', b.price ?? 0, b.quantity ?? 0]
+                });
+                sendJson(response, JSON.stringify({
+                    id: r.rows[0].id, name: b.name, category: b.category,
+                    price: b.price, quantity: b.quantity
+                }), 201);
+            } catch (e) { dbError(response, 'insert failed'); }
+        });
+
+        // Cache-aside on Redis where the harness provides it - crud is the one profile
+        // that does.
+        server.get('/crud/items/:id', async (request, response) => {
+            if (!pgPool) return dbError(response, 'DB not available');
+            const id = parseInt(request.path_parameters.id, 10);
+            if (id !== id) return response.status(404).header('server', SERVER_HDR).send('');
+            try {
+                if (redis) {
+                    const hit = await redis.get('crud:' + id);
+                    if (hit) return sendJson(response, hit, 200, { 'x-cache': 'HIT' });
+                }
+                const r = await pgPool.query({
+                    name: 'crud-read',
+                    text: `SELECT ${ITEM_COLUMNS} FROM items WHERE id = $1 LIMIT 1`,
+                    values: [id]
+                });
+                if (r.rows.length === 0) return response.status(404).header('server', SERVER_HDR).send('');
+                const body = JSON.stringify(itemShape(r.rows[0]));
+                if (redis) redis.set('crud:' + id, body, 'PX', CRUD_TTL_MS);
+                sendJson(response, body, 200, { 'x-cache': 'MISS' });
+            } catch (e) { dbError(response, 'query failed'); }
+        });
+
+        server.put('/crud/items/:id', async (request, response) => {
+            if (!pgPool) return dbError(response, 'DB not available');
+            const id = parseInt(request.path_parameters.id, 10);
+            if (id !== id) return response.status(404).header('server', SERVER_HDR).send('');
+            const b = await readJson(request);
+            if (!b) return dbError(response, 'update failed');
+            try {
+                const r = await pgPool.query({
+                    name: 'crud-update',
+                    text: 'UPDATE items SET name = $1, price = $2, quantity = $3 WHERE id = $4',
+                    values: [b.name ?? 'Updated', b.price ?? 0, b.quantity ?? 0, id]
+                });
+                if (r.rowCount === 0) return response.status(404).header('server', SERVER_HDR).send('');
+                if (redis) await redis.del('crud:' + id);
+                sendJson(response, JSON.stringify({ id, name: b.name, price: b.price, quantity: b.quantity }));
+            } catch (e) { dbError(response, 'update failed'); }
+        });
+
+        server.get('/fortunes', async (request, response) => {
+            if (!pgPool) {
+                return response.status(500).header('server', SERVER_HDR).type('text/plain').send('DB not available');
+            }
+            try {
+                const r = await pgPool.query({ name: 'fortunes', text: 'SELECT id, message FROM fortune' });
+                const all = r.rows.map(x => ({ id: x.id, message: x.message }));
+                all.push({ id: 0, message: RUNTIME_FORTUNE });
+                // Ordinal, not locale aware: the seed carries em-dashes and collation rules
+                // would order them in a way the profile does not ask for.
+                all.sort((a, b) => (a.message < b.message ? -1 : a.message > b.message ? 1 : 0));
+                let body = '<!DOCTYPE html><html><head><title>Fortunes</title></head><body><table>' +
+                    '<tr><th>id</th><th>message</th></tr>';
+                for (const f of all) body += '<tr><td>' + f.id + '</td><td>' + escapeHtml(f.message) + '</td></tr>';
+                body += '</table></body></html>';
+                response.header('server', SERVER_HDR).type('text/html; charset=utf-8').send(body);
+            } catch (e) {
+                response.status(500).header('server', SERVER_HDR).type('text/plain').send('query failed');
+            }
+        });
+
+        // The request is a lazy Readable: counting bytes never needs the 20 MB body in memory,
+        // which is what request.buffer() would cost
+        server.post('/upload', (request, response) => {
+            let size = 0;
+            request.on('data', chunk => size += chunk.length);
+            request.on('end', () => {
+                response.header('server', SERVER_HDR).type('text/plain').send(String(size));
+            });
+        });
+
+        server.get('/baseline2', (request, response) => {
+            response.header('server', SERVER_HDR).type('text/plain').send(String(sumQuery(request.query_parameters)));
+        });
+
+        server.any('/baseline11', async (request, response) => {
+            let total = sumQuery(request.query_parameters);
+            if (request.method === 'POST') {
+                const n = parseInt((await request.text()).trim(), 10);
+                if (n === n) total += n;
+            }
+            response.header('server', SERVER_HDR).type('text/plain').send(String(total));
+        });
+
+        server.get('/static/:filename', (request, response) => {
+            const sf = staticFiles[request.path_parameters.filename];
+            if (!sf) return response.status(404).header('server', SERVER_HDR).send('Not found');
+            const ae = request.headers['accept-encoding'] || '';
+            let path = sf.path;
+            let encoding = null;
+            if (sf.br && ae.includes('br')) {
+                path += '.br';
+                encoding = 'br';
+            } else if (sf.gz && ae.includes('gzip')) {
+                path += '.gz';
+                encoding = 'gzip';
+            }
+            fs.readFile(path, (err, buf) => {
+                if (err) return response.status(404).header('server', SERVER_HDR).send('Not found');
+                response.header('server', SERVER_HDR).header('content-type', sf.ct);
+                if (encoding) response.header('content-encoding', encoding);
+                response.send(buf);
+            });
+        });
+
+        return server;
+    }
+
+    // max_body_length defaults to 250 KB and answers 413 above it, so the upload profile,
+    // which posts up to 20 MB, needs the cap raised. Every worker binds :8080 on its own:
+    // uWebSockets.js shares the port between processes unless exclusive_port is asked for.
+    const OPTIONS = { max_body_length: 32 * 1024 * 1024 };
+
+    registerRoutes(new Server(OPTIONS)).listen(8080);
+
+    // json-tls and static-tls on 8081. hyper-express takes its TLS material through the
+    // uWS options at construction rather than a separate https server, so the port is a
+    // second Server carrying the same routes. Every worker binds it, the same way they
+    // all bind 8080, so the listener is spread across the cluster rather than parked on
+    // one process. The harness only mounts /certs for the TLS profiles.
+    const CERT = '/certs/server.crt';
+    const KEY = '/certs/server.key';
+    if (fs.existsSync(CERT) && fs.existsSync(KEY)) {
+        registerRoutes(new Server({
+            ...OPTIONS,
+            key_file_name: KEY,
+            cert_file_name: CERT
+        })).listen(8081);
+    }
 }
diff --git a/frameworks/hyper-express/meta.json b/frameworks/hyper-express/meta.json
index 5661ad9b3..79e74940b 100644
--- a/frameworks/hyper-express/meta.json
+++ b/frameworks/hyper-express/meta.json
@@ -19,7 +19,15 @@
     "limited-conn",
     "json",
     "json-comp",
-    "upload"
+    "json-tls",
+    "upload",
+    "static",
+    "static-tls",
+    "async-db",
+    "crud",
+    "fortunes",
+    "api-4",
+    "api-16"
   ],
   "maintainers": []
 }
diff --git a/frameworks/hyper-express/package.json b/frameworks/hyper-express/package.json
index 728edf67f..1e225975b 100644
--- a/frameworks/hyper-express/package.json
+++ b/frameworks/hyper-express/package.json
@@ -2,6 +2,8 @@
   "name": "httparena-hyper-express",
   "private": true,
   "dependencies": {
-    "hyper-express": "^7.0.2"
+    "hyper-express": "^7.0.2",
+    "pg": "^8.13.0",
+    "ioredis": "^5.4.1"
   }
 }
diff --git a/site/data/results/hyper-express.json b/site/data/results/hyper-express.json
index 06401b04f..d7d1106a9 100644
--- a/site/data/results/hyper-express.json
+++ b/site/data/results/hyper-express.json
@@ -1,22 +1,94 @@
 {
   "framework": "hyper-express",
   "results": {
+    "api-16-1024": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 113098,
+      "avg_latency": "7.46ms",
+      "p99_latency": "69.40ms",
+      "cpu": "1485.8%",
+      "memory": "1.4GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "573.32MB/s",
+      "input_bw": "6.36MB/s",
+      "reconnects": 339213,
+      "status_2xx": 1696476,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "tpl_baseline": 634853,
+      "tpl_json": 637214,
+      "tpl_db": 0,
+      "tpl_upload": 0,
+      "tpl_static": 0,
+      "tpl_async_db": 424408
+    },
+    "api-4-256": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 32019,
+      "avg_latency": "6.82ms",
+      "p99_latency": "50.70ms",
+      "cpu": "398.9%",
+      "memory": "385MiB",
+      "connections": 256,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "162.10MB/s",
+      "input_bw": "1.80MB/s",
+      "reconnects": 96066,
+      "status_2xx": 480287,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "tpl_baseline": 180112,
+      "tpl_json": 179883,
+      "tpl_db": 0,
+      "tpl_upload": 0,
+      "tpl_static": 0,
+      "tpl_async_db": 120292
+    },
+    "async-db-1024": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 199327,
+      "avg_latency": "4.66ms",
+      "p99_latency": "23.10ms",
+      "cpu": "6106.7%",
+      "memory": "2.9GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "767.70MB/s",
+      "input_bw": "13.31MB/s",
+      "reconnects": 79356,
+      "status_2xx": 1993276,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
     "baseline-4096": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 1157423,
-      "avg_latency": "3.54ms",
-      "p99_latency": "9.59ms",
-      "cpu": "6565.7%",
-      "memory": "5.7GiB",
+      "rps": 1167706,
+      "avg_latency": "3.51ms",
+      "p99_latency": "7.19ms",
+      "cpu": "6554.9%",
+      "memory": "5.6GiB",
       "connections": 4096,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "155.60MB/s",
-      "input_bw": "89.41MB/s",
+      "bandwidth": "156.98MB/s",
+      "input_bw": "90.20MB/s",
       "reconnects": 0,
-      "status_2xx": 5787119,
+      "status_2xx": 5838533,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -24,19 +96,58 @@
     "baseline-512": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 1170789,
-      "avg_latency": "436us",
-      "p99_latency": "1.35ms",
-      "cpu": "6738.2%",
-      "memory": "5.8GiB",
+      "rps": 1175888,
+      "avg_latency": "434us",
+      "p99_latency": "1.20ms",
+      "cpu": "6756.1%",
+      "memory": "5.6GiB",
       "connections": 512,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "157.39MB/s",
-      "input_bw": "90.44MB/s",
+      "bandwidth": "158.08MB/s",
+      "input_bw": "90.83MB/s",
+      "reconnects": 0,
+      "status_2xx": 5879442,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "crud-4096": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 351171,
+      "avg_latency": "11.60ms",
+      "p99_latency": "21.70ms",
+      "cpu": "4618.9%",
+      "memory": "7.0GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "124.05MB/s",
+      "input_bw": "30.14MB/s",
+      "reconnects": 23614,
+      "status_2xx": 5267578,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "fortunes-1024": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 83872,
+      "avg_latency": "11.03ms",
+      "p99_latency": "21.60ms",
+      "cpu": "6534.6%",
+      "memory": "3.8GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "1.94GB/s",
       "reconnects": 0,
-      "status_2xx": 5853947,
+      "status_2xx": 419364,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -44,19 +155,19 @@
     "json-4096": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 865641,
-      "avg_latency": "4.43ms",
-      "p99_latency": "13.10ms",
-      "cpu": "6455.2%",
+      "rps": 860837,
+      "avg_latency": "4.46ms",
+      "p99_latency": "13.20ms",
+      "cpu": "6615.5%",
       "memory": "1.8GiB",
       "connections": 4096,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "2.96GB/s",
-      "input_bw": "41.28MB/s",
-      "reconnects": 171385,
-      "status_2xx": 4328207,
+      "bandwidth": "2.94GB/s",
+      "input_bw": "41.05MB/s",
+      "reconnects": 170789,
+      "status_2xx": 4304186,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -64,19 +175,19 @@
     "json-comp-16384": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 439207,
-      "avg_latency": "36.88ms",
-      "p99_latency": "86.00ms",
-      "cpu": "6296.9%",
-      "memory": "8.4GiB",
+      "rps": 436029,
+      "avg_latency": "37.31ms",
+      "p99_latency": "88.00ms",
+      "cpu": "6587.2%",
+      "memory": "8.7GiB",
       "connections": 16384,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "668.34MB/s",
-      "input_bw": "32.67MB/s",
-      "reconnects": 81390,
-      "status_2xx": 2196039,
+      "bandwidth": "663.47MB/s",
+      "input_bw": "32.43MB/s",
+      "reconnects": 80516,
+      "status_2xx": 2180147,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -84,19 +195,19 @@
     "json-comp-4096": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 442051,
-      "avg_latency": "9.24ms",
-      "p99_latency": "26.30ms",
-      "cpu": "6356.4%",
-      "memory": "8.7GiB",
+      "rps": 437977,
+      "avg_latency": "9.33ms",
+      "p99_latency": "26.80ms",
+      "cpu": "6306.8%",
+      "memory": "9.0GiB",
       "connections": 4096,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "672.63MB/s",
-      "input_bw": "32.88MB/s",
-      "reconnects": 86828,
-      "status_2xx": 2210255,
+      "bandwidth": "666.44MB/s",
+      "input_bw": "32.58MB/s",
+      "reconnects": 85951,
+      "status_2xx": 2189885,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -104,19 +215,38 @@
     "json-comp-512": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 426932,
-      "avg_latency": "1.19ms",
-      "p99_latency": "5.93ms",
-      "cpu": "5994.8%",
+      "rps": 421586,
+      "avg_latency": "1.21ms",
+      "p99_latency": "6.29ms",
+      "cpu": "5904.9%",
       "memory": "8.8GiB",
       "connections": 512,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "649.68MB/s",
-      "input_bw": "31.76MB/s",
-      "reconnects": 85383,
-      "status_2xx": 2134662,
+      "bandwidth": "641.51MB/s",
+      "input_bw": "31.36MB/s",
+      "reconnects": 84320,
+      "status_2xx": 2107930,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "json-tls-4096": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 801048,
+      "avg_latency": "5.09ms",
+      "p99_latency": "121.61ms",
+      "cpu": "6632.6%",
+      "memory": "1.8GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "2.74GB",
+      "reconnects": 0,
+      "status_2xx": 4086305,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -124,19 +254,19 @@
     "limited-conn-4096": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 1061742,
-      "avg_latency": "3.85ms",
-      "p99_latency": "16.60ms",
-      "cpu": "6467.2%",
-      "memory": "5.8GiB",
+      "rps": 1082245,
+      "avg_latency": "3.77ms",
+      "p99_latency": "16.20ms",
+      "cpu": "6429.5%",
+      "memory": "5.9GiB",
       "connections": 4096,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "142.73MB/s",
-      "input_bw": "82.02MB/s",
-      "reconnects": 530577,
-      "status_2xx": 5308713,
+      "bandwidth": "145.49MB/s",
+      "input_bw": "83.60MB/s",
+      "reconnects": 540774,
+      "status_2xx": 5411227,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -144,19 +274,19 @@
     "limited-conn-512": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 970368,
-      "avg_latency": "518us",
-      "p99_latency": "3.01ms",
-      "cpu": "6218.4%",
-      "memory": "6.0GiB",
+      "rps": 964073,
+      "avg_latency": "521us",
+      "p99_latency": "3.09ms",
+      "cpu": "6177.4%",
+      "memory": "6.1GiB",
       "connections": 512,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "130.45MB/s",
-      "input_bw": "74.96MB/s",
-      "reconnects": 485185,
-      "status_2xx": 4851843,
+      "bandwidth": "129.60MB/s",
+      "input_bw": "74.47MB/s",
+      "reconnects": 482047,
+      "status_2xx": 4820366,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -164,18 +294,18 @@
     "pipelined-4096": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 3519939,
-      "avg_latency": "18.62ms",
-      "p99_latency": "25.50ms",
-      "cpu": "6430.0%",
-      "memory": "2.2GiB",
+      "rps": 3516134,
+      "avg_latency": "18.64ms",
+      "p99_latency": "23.10ms",
+      "cpu": "6440.4%",
+      "memory": "2.3GiB",
       "connections": 4096,
       "threads": 64,
       "duration": "5s",
       "pipeline": 16,
-      "bandwidth": "473.16MB/s",
+      "bandwidth": "472.63MB/s",
       "reconnects": 0,
-      "status_2xx": 17599696,
+      "status_2xx": 17580672,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -183,18 +313,132 @@
     "pipelined-512": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 3510937,
-      "avg_latency": "2.33ms",
-      "p99_latency": "5.40ms",
-      "cpu": "6477.5%",
+      "rps": 3505715,
+      "avg_latency": "2.34ms",
+      "p99_latency": "5.64ms",
+      "cpu": "6501.1%",
       "memory": "2.1GiB",
       "connections": 512,
       "threads": 64,
       "duration": "5s",
       "pipeline": 16,
-      "bandwidth": "471.92MB/s",
+      "bandwidth": "471.31MB/s",
+      "reconnects": 0,
+      "status_2xx": 17528576,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "static-1024": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 510027,
+      "avg_latency": "2.10ms",
+      "p99_latency": "30.98ms",
+      "cpu": "6510.6%",
+      "memory": "2.5GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "7.80GB",
+      "reconnects": 0,
+      "status_2xx": 2600981,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "static-4096": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 570792,
+      "avg_latency": "7.19ms",
+      "p99_latency": "28.36ms",
+      "cpu": "6512.1%",
+      "memory": "3.6GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "8.73GB",
+      "reconnects": 0,
+      "status_2xx": 2910741,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "static-6800": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 568500,
+      "avg_latency": "11.91ms",
+      "p99_latency": "49.51ms",
+      "cpu": "6550.3%",
+      "memory": "3.6GiB",
+      "connections": 6800,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "8.69GB",
+      "reconnects": 0,
+      "status_2xx": 2899854,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "static-tls-1024": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 410499,
+      "avg_latency": "2.55ms",
+      "p99_latency": "33.11ms",
+      "cpu": "6522.0%",
+      "memory": "2.4GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "6.28GB",
+      "reconnects": 0,
+      "status_2xx": 2093293,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "static-tls-4096": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 449618,
+      "avg_latency": "9.10ms",
+      "p99_latency": "88.86ms",
+      "cpu": "6485.4%",
+      "memory": "3.6GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "6.87GB",
+      "reconnects": 0,
+      "status_2xx": 2292826,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "static-tls-6800": {
+      "framework": "hyper-express",
+      "language": "JS",
+      "rps": 446114,
+      "avg_latency": "15.21ms",
+      "p99_latency": "157.29ms",
+      "cpu": "6511.7%",
+      "memory": "3.6GiB",
+      "connections": 6800,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "6.82GB",
       "reconnects": 0,
-      "status_2xx": 17554688,
+      "status_2xx": 2275532,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -202,19 +446,19 @@
     "upload-256": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 2194,
-      "avg_latency": "112.76ms",
-      "p99_latency": "874.10ms",
-      "cpu": "6010.6%",
+      "rps": 2178,
+      "avg_latency": "112.53ms",
+      "p99_latency": "884.40ms",
+      "cpu": "5924.3%",
       "memory": "6.2GiB",
       "connections": 256,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "313.70KB/s",
-      "input_bw": "17.40GB/s",
-      "reconnects": 2174,
-      "status_2xx": 10995,
+      "bandwidth": "311.35KB/s",
+      "input_bw": "17.28GB/s",
+      "reconnects": 2153,
+      "status_2xx": 10914,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
@@ -222,19 +466,19 @@
     "upload-32": {
       "framework": "hyper-express",
       "language": "JS",
-      "rps": 2070,
-      "avg_latency": "15.42ms",
-      "p99_latency": "94.20ms",
-      "cpu": "2773.3%",
+      "rps": 2064,
+      "avg_latency": "15.49ms",
+      "p99_latency": "90.60ms",
+      "cpu": "2933.8%",
       "memory": "5.8GiB",
       "connections": 32,
       "threads": 64,
       "duration": "5s",
       "pipeline": 1,
-      "bandwidth": "295.51KB/s",
-      "input_bw": "16.42GB/s",
-      "reconnects": 2068,
-      "status_2xx": 10352,
+      "bandwidth": "294.71KB/s",
+      "input_bw": "16.37GB/s",
+      "reconnects": 2062,
+      "status_2xx": 10324,
       "status_3xx": 0,
       "status_4xx": 0,
       "status_5xx": 0
diff --git a/site/static/logs/api-16/1024/hyper-express.log b/site/static/logs/api-16/1024/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/api-4/256/hyper-express.log b/site/static/logs/api-4/256/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/async-db/1024/hyper-express.log b/site/static/logs/async-db/1024/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/crud/4096/hyper-express.log b/site/static/logs/crud/4096/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/fortunes/1024/hyper-express.log b/site/static/logs/fortunes/1024/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/json-tls/4096/hyper-express.log b/site/static/logs/json-tls/4096/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/static-tls/1024/hyper-express.log b/site/static/logs/static-tls/1024/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/static-tls/4096/hyper-express.log b/site/static/logs/static-tls/4096/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/static-tls/6800/hyper-express.log b/site/static/logs/static-tls/6800/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/static/1024/hyper-express.log b/site/static/logs/static/1024/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/static/4096/hyper-express.log b/site/static/logs/static/4096/hyper-express.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/static/6800/hyper-express.log b/site/static/logs/static/6800/hyper-express.log
new file mode 100644
index 000000000..e69de29bb