slowdep

Wrap any async function with realistic latency. Test how your app survives slow, unpredictable dependencies.

npm install slowdep

The problem with setTimeout

When you test against a slow dependency, you probably do something like:

await new Promise(r => setTimeout(r, 200)); // simulate DB

Real databases don't work like that. In production, your Postgres instance responds in 5ms most of the time, 200ms occasionally, and 2000ms when something's wrong. A flat 200ms delay doesn't test the case that actually breaks your app — the variance.

slowdep samples from a lognormal distribution fitted to your p50/p99 targets. That's the same statistical shape real production systems follow: fast most of the time, occasionally slow, rarely very slow.

---

Usage

Drop-in preset

import { withLatency } from 'slowdep';

const findUser = async (id) => db.query('SELECT * FROM users WHERE id = $1', [id]);

// Now behaves like a real Postgres call: p50=5ms, p95=50ms, p99=200ms
const slowFindUser = withLatency(findUser, 'postgres');

const user = await slowFindUser(42); // realistically slow, every call different

Custom profile

const slowFetch = withLatency(fetchExternalAPI, {
  p50: 100,   // typical call: ~100ms
  p99: 2000,  // worst 1%: up to 2 seconds
  errorRate: 0.01, // 1% of calls throw a transient error
});

Wrap an entire client

import { withLatencyAll } from 'slowdep';

const slowRedis = withLatencyAll(redisClient, 'redis');

await slowRedis.get('key');   // slow
await slowRedis.set('k', 'v'); // also slow

Standalone delay

import { slowdepDelay } from 'slowdep';

await slowdepDelay('stripe');
// continues after a Stripe-realistic delay

---

Presets

Built-in profiles based on real-world p50/p95/p99 data:

Preset	p50	p95	p99	Error rate
postgres	5ms	50ms	200ms	0.1%
mysql	4ms	40ms	180ms	0.1%
redis	1ms	5ms	20ms	0.05%
mongodb	8ms	60ms	250ms	0.1%
dynamodb	3ms	15ms	50ms	0.05%
s3	30ms	150ms	500ms	0.1%
stripe	200ms	800ms	2000ms	0.2%
openai	800ms	3000ms	8000ms	0.5%
anthropic	600ms	2500ms	7000ms	0.5%
http	80ms	300ms	1000ms	1%

---

Why lognormal?

Latency distributions in distributed systems are right-skewed: most requests are fast, but a long tail of slow requests exists due to GC pauses, cold caches, network jitter, and noisy neighbors. The lognormal distribution captures this shape accurately.

slowdep fits a lognormal curve to your p50 and p99 values, so every sampled delay reflects the statistical reality of production traffic — not a flat number that gives you false confidence.

---

API

withLatency(fn, profile)

Wraps an async function. Returns a function with the identical signature.

• fn — any async function
• profile — preset name ('postgres', 'redis', etc.) or { p50, p99, p95?, errorRate? }

withLatencyAll(obj, profile)

Wraps every async method on an object with the same profile. Non-function properties are preserved.

slowdepDelay(profile)

Returns a Promise<void> that resolves after a realistic delay. No function needed.

presets

The raw preset config object — import and inspect or extend:

import { presets } from 'slowdep';
console.log(presets.postgres); // { p50: 5, p95: 50, p99: 200, errorRate: 0.001 }

---

TypeScript

Full types included. No @types/ package needed.

import { withLatency, LatencyProfile, PresetName } from 'slowdep';

const profile: LatencyProfile = { p50: 50, p99: 500, errorRate: 0.005 };
const slowFn = withLatency(myFn, profile);

---

Who is this for?

• Backend engineers building resilient Node.js services
• Anyone writing retry logic, circuit breakers, or timeout handling
• Teams doing chaos engineering without a full infrastructure setup
• Claude Code and AI coding agents that scaffold retry/fallback logic and need to test it

---

License

MIT