Kubai Kevin

Redis vs Valkey vs Dragonfly: which in-memory store?

A mechanism-first guide to picking Redis, Valkey or Dragonfly: fork history, single-thread limits, expiry semantics, migration tests and metrics.

17 min read · 7 November 2026

Rate limiters: burst vs abuse, two designs

Two rate limiter designs compared: token bucket with concurrency cap versus sliding window with penalty box, plus how to tune and measure each.

15 min read · 11 October 2026

Dead-letter queues: stop poison messages

Design retry caps, DLQs, and alerts so a poison message is isolated in seconds. Includes working Redis Queue code and pytest tests.

15 min read · 21 September 2026

Memory Systems for Production Agents

How in-memory stores, caches, and stateful services leak context in production agents, plus code, failure modes, and instrumentation to measure it yourself.

11 min read · 15 September 2026

Stop assuming payment APIs never fail

How to combine AI recommendations with M-Pesa, Paystack and Flutterwave calls so gateway timeouts, rate limits and duplicate charges don't break checkout.

13 min read · 13 September 2026

Why your routing layer will collapse at scale

How to build stateful, region-aware LLM routing: config schema, retry budgets, circuit breakers, audit trails, and the failure modes to plan for.

12 min read · 4 September 2026

IDP for AI: 2026 stack evolution

How to wire embedding model changes into an internal developer platform so dimension drift fails loudly instead of silently shipping broken indexes.

14 min read · 2 September 2026

Prevent ownership drift when velocity explodes

How to keep clear ownership of caches, SLOs and services when teams ship faster: deployment boundaries, error budgets, stampede locks and useful telemetry.

15 min read · 29 August 2026

AI features rot faster than you build them

Model APIs, prompts and schemas change under you. Here is how to make AI feature contracts explicit, versioned and reversible without a rewrite.

15 min read · 27 August 2026

AI on slow networks: Nairobi teams' 2026 playbook

How to cut perceived AI latency with multi-tier caching, stampede guards, and edge orchestration, plus how to measure each layer yourself.

13 min read · 26 August 2026

AI errors hide in plain latency

Why token counts and GPU utilization miss user-visible AI degradation, and how to instrument end-to-end p95/p99 latency and error rate instead.

10 min read · 21 August 2026

Evolve your monolith without rewriting in 2026

A three-layer FastAPI layout (API, domain, infra) that keeps a monolith evolvable: worked code, failure modes, cache stampede fixes, and how to measure.

15 min read · 19 August 2026

Replace managed services with Postgres 17

How to decide whether to replace managed cache, search, and scheduler services with Postgres extensions, and how to measure the trade-off honestly.

14 min read · 16 August 2026

Rust SDK vs FastAPI for LLM ops: trust in 2026

How to compare a compiled Rust inference service against a Python async API for LLM serving: cold starts, cache stampedes, memory, and how to measure each.

10 min read · 14 August 2026

Senior engineer title inflation in 2026

How AI-generated code changes senior-engineer expectations: residency-aware LLM gateways, retry budgets, audit logs, and verification you can run.

11 min read · 13 August 2026

Spot evictions: the retry logic that holds up

Spot evictions break naive retry logic. Learn how to decouple retries from instance lifecycle, add jitter, and avoid coordinated retry storms.

13 min read · 12 August 2026

Orchestration tax kills multi-agent systems

Why coordination layers dominate multi-agent latency and memory, with patterns that remove the scheduler and how to measure your own orchestration tax.

13 min read · 11 August 2026

Designing APIs for High-Latency Satellite Links

How to keep an API reliable over high-latency satellite links: circuit breakers, retry budgets, failover gateways, and the metrics that show what broke.

14 min read · 10 August 2026

Cost-Effective AI Infrastructure for Micro-SaaS

How to architect an AI micro-SaaS on a tight budget: caching, batching, serverless scaling, cost measurement, and the failure modes that break naive designs.

15 min read · 5 August 2026

Senior role projects: 3 real paths

Build three portfolio projects that demonstrate tenant isolation, retry-storm handling, and event sourcing, with concrete ways to measure each claim.

16 min read · 5 August 2026

Event-driven systems avoid agent-driven contention

How to tell when scheduled jobs and polling loops quietly turn an event-driven system into an agent-driven one, and how to fix it without a rewrite.

15 min read · 30 July 2026

Built a multi-agent system without LangGraph

Build a multi-agent research pipeline with Redis Streams, Step Functions retries and FastAPI, plus the failure modes that matter and how to measure them.

13 min read · 27 July 2026

Context windows live longer than you think

Long-running agents exhaust context windows through unbounded history growth. Covers pruning, summarisation, retrieval, and retention policies with code.

13 min read · 25 July 2026

Edge agents vs cloud round-trips in 2026

A practical guide to building on-device agents with ONNX Runtime, Redis caching, confidence-based cloud fallback, and honest ways to measure latency and memory.

11 min read · 23 July 2026

Observability for Long-Running LLM Agent Workflows

Design an observability stack for agentic LLM workloads: millisecond event timestamps, queue-depth metrics, and bounded buffering that survives outages.

14 min read · 17 July 2026

Stabilize multi-model agent routers: six production rules

Six rules for multi-model agent routers: bounded concurrency, idempotency keys, timeouts, observability, and how to measure each one yourself.

15 min read · 15 July 2026

Agent context: short-term vs long-term memory

Compare Redis-style short-term agent context with Postgres event logs: latency, durability, auditability, cost, and how to measure each.

15 min read · 9 July 2026

Observability for LLM Features: Metrics That Drive Decisions

Log one structured event per LLM interaction instead of tracing every token, then alert only on user-facing outcomes that justify keeping a feature.

14 min read · 8 July 2026

7 ways to measure prompt platform ROI in 2026

How to attribute token cost, latency and developer time to prompt and agent platforms, with instrumentation recipes, failure modes and a decision checklist.

14 min read · 8 July 2026

AI feature drift: why your model died at midnight

Diagnose nightly AI model drift and FeatureStoreKeyNotFound errors: tokenizer drift, memory fragmentation, and cold-start timeouts, with fixes.

14 min read · 7 July 2026

Build agent workflows that survive restarts

How to build agent task pipelines that resume after crashes, schema drift and model changes, using Redis streams, idempotent steps and replay.

12 min read · 6 July 2026

AI in slow networks: why models flop where data costs rise

How to cut payload size, round-trips and cost for AI features on 2G/3G networks, with a worked ASR example, failure modes and a measurement checklist.

14 min read · 5 July 2026

AI agents: circuit breakers are not optional

AI agents fail by hanging and returning plausible garbage, not by crashing. Here is how to add a circuit breaker that catches semantic failures.

13 min read · 3 July 2026

Serve 4G-as-baseline apps in 2026

Design APIs for 300 ms RTT, packet loss and data caps: payload budgets, stale-while-revalidate caching, adaptive fetch and honest measurement.

14 min read · 3 July 2026

AI memory systems: context that survives sessions

Why AI agents silently lose memory across restarts, how to scope memory to a session, and how to test persistence before production.

12 min read · 2 July 2026

Postgres 17 swallowed Redis, Kafka, Timescale

How to evaluate consolidating Redis, Kafka and a time-series database into Postgres extensions, with honest limits, failure modes and a checklist.

14 min read · 2 July 2026

AI agents killed dev tool sales cycles

How agent-driven evaluation changes integration design, onboarding, and pricing for developer tools, with concrete patterns and a 30-minute test.

10 min read · 2 July 2026

9 Vibe coding traps that break production code

Nine patterns that make AI-assisted prototypes fail under load, with the instrumentation to catch each one before it reaches production.

11 min read · 1 July 2026

Bank APIs broke under African 2G

Why aggressive caching and remote idempotency stores fail on flaky 2G/3G links, and how to instrument, measure, and redesign balance endpoints for it.

14 min read · 28 June 2026

Monolith to services without a rewrite

Most monolith-to-services migrations fail on data coupling, not code structure. Here is how to audit coupling and measure the latency tax before extracting.

14 min read · 27 June 2026

Starlink 4G fallback: serve pages under 800ms

How to build a streaming HTML shell, small client bundle and edge cache that keeps TTFB under 800ms on 4G, satellite and low-end Android devices.

13 min read · 26 June 2026

Postgres 17 buried Redis, S3, cron

How to evaluate Postgres 17 as a cache, scheduler and blob store, with measurement steps, failure modes and a decision checklist.

11 min read · 26 June 2026

Webhooks done right: retries that don’t explode in 2026

A practical guide to webhook delivery: idempotency, retry budgets, silent rate limits, poison-message triage, and what to instrument before you scale.

10 min read · 25 June 2026

Store data once, serve everywhere: cheaper

How to serve reads from regional caches instead of replicating your database everywhere, with worked cost math, invalidation code, and failure modes.

12 min read · 25 June 2026

API abuse patterns rising in 2026

A layered architecture for stopping credential stuffing and scraping: client integrity tokens, cohort-based rate limiting, and behavioral scoring at the CDN edge.

12 min read · 24 June 2026

JSON mode’s silent failures exposed

JSON mode enforces grammar, not your contract. Here is how to build a schema-validated envelope pipeline with deterministic repair and quarantine.

11 min read · 21 June 2026

AI stole system design

AI can generate a polished system design in seconds. Here is how to redesign interviews around live debugging so you test real understanding.

11 min read · 21 June 2026

Vibe code: works great, fails forever

Ten failure modes that make vibe-coded MVPs unmaintainable, with code fixes, measurement recipes, and a hardening checklist for each.

13 min read · 20 June 2026

Defending APIs Against Amplification, Stuffing and Smuggling

How cache-stampede amplification, credential stuffing and HTTP/2 request smuggling work, plus edge admission, idempotency keys and circuit breakers that blunt them.

13 min read · 20 June 2026

Tiered API abuse defense: match cost to attacker economics

Five API abuse patterns that inflate cloud bills, why edge-only blocking fails, and how to build tiered defenses with measurable cost-per-request targets.

11 min read · 20 June 2026

Regulations forced better APIs: the 2026 fintech

Why payment APIs need durable state machines, explicit retry policies, and status endpoints that survive restarts — and when the old synchronous playbook still works.

13 min read · 20 June 2026

Webhook Delivery: Retries, Idempotency, and Durability

Design reliable webhook ingestion with durable buffering, idempotency keys, bounded retries, and circuit breakers, plus how to measure each guarantee.

11 min read · 19 June 2026

Tool calling: stateless beats stateful under load

How request-scoped and pooled tool calls behave under load, what to instrument, and a decision checklist for choosing between them.

11 min read · 19 June 2026

Why monoliths die slowly in 2026

Monolith decomposition usually fails on data locality, not routing. A step-by-step order for extracting data first, routing traffic later, with checks.

13 min read · 19 June 2026

AI Interviews: Four Resilience Questions That Matter

AI screening interviews grade production resilience, not algorithm puzzles. Learn the four fault-injection questions and how to measure candidate fixes.

13 min read · 14 June 2026

AI-native apps: forget the old stack

LLM-backed services are token-bound, stateful and failure-prone. Learn the failure modes, how to measure them, and patterns that contain them.

10 min read · 12 June 2026

RAG in prod: what tutorials won’t tell you

Why nightly embedding refreshes break RAG latency, and how a hot/cold retrieval split with partial vector updates fixes it.

14 min read · 8 June 2026