Kubai Kevin

53 articles tagged Containers

Kubernetes Requests and Limits: Seven Production Traps

Why pods get OOMKilled, throttled, or evicted: seven common requests-and-limits mistakes, how to detect each with real metrics, and which to fix first.

15 min read · 16 November 2026

Python deps: uv vs Poetry vs pip-tools

Compare uv, Poetry and pip-tools by resolver, lockfile and environment model, with a worked example, failure modes and a decision checklist.

12 min read · 15 November 2026

Virtual threads: what actually changes

What virtual threads change in a blocking Java service, where the real bottleneck moves, how pinning and thread-locals bite, and how to measure it.

15 min read · 13 November 2026

Distroless images: smaller attack surface

How to move runtime containers to distroless bases, measure the reduction in packages and CVEs, and keep scans blocking in CI.

13 min read · 2 November 2026

Node.js memory leak: find it in 10 min

Classify rising memory before profiling it: compare heapUsed and rss, take two heap snapshots, read retainer paths, and bound every in-memory structure.

14 min read · 29 October 2026

HPA vs KEDA vs Karpenter: autoscaling traps

How HPA, KEDA and Karpenter divide responsibility, where each one silently fails, and how to verify each layer before traffic arrives.

17 min read · 26 October 2026

Core Web Vitals: what actually moves the needle

A decision framework for Core Web Vitals: read field distributions, find fixed costs that hit the slow tail, and verify changes with segmented RUM.

16 min read · 7 October 2026

Deployment platforms: senior vs new hire

How to build a deployment platform that serves both senior engineers and new hires, with escape hatches, guardrails, and a decision checklist.

17 min read · 7 October 2026

SBOM + attestation that gets used

How to generate, sign, attach and enforce SBOMs and build attestations so admission control and CI gates reject unverified artifacts.

17 min read · 3 October 2026

Sandboxed computer-use agents with gVisor

How to contain computer-use agents using gVisor, egress allowlists, and short-lived credentials, with code, failure modes, and planning figures.

14 min read · 21 September 2026

Golden paths that don't handcuff

How to build internal scaffolds and CLIs that stay reversible: pinned versions, a compatibility contract, drift detection, and a tested eject path.

12 min read · 21 September 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

AI Supply Chain Security: Trust Boundaries for Model Artifacts

How to reason about trust boundaries for AI artifacts when pickle, torch.load and remote code execution are the format, plus a practical detection stack.

16 min read · 19 September 2026

Scope agent permissions per task

Most agent permission models fail because credentials are scoped to the agent, not the task. Here is how to issue short-lived, task-scoped tokens and what to measure.

20 min read · 19 September 2026

Stop Putting LLM Keys in .env

Why flat .env files fail at scale for LLM API keys, and how a secrets manager plus gateway brokering scoped credentials fixes rotation and leaks.

14 min read · 17 September 2026

Agent API versioning: why clients break on upgrade

Why agent version upgrades break downstream clients, the contract drift behind the errors, and how to pin, check and roll out versions safely.

12 min read · 14 September 2026

Why ML Models Drift After Deployment

Offline validation rarely matches production traffic. Learn the evaluation gap, how to measure drift, and concrete checks to add before your next deploy.

16 min read · 11 September 2026

LLM agents: why monoliths win

Why splitting an LLM agent into micro-services often costs latency, audit continuity and money, and how to measure before you decompose.

11 min read · 10 September 2026

Agent drift: why it hurts UX

Agent drift degrades latency and error rates without obvious alarms. Learn the four drift classes, detection methods, and a 30-minute audit.

12 min read · 9 September 2026

Portfolio projects that hire remote senior devs

Build a portfolio that proves operational rigor: caching, rate limiting, observability, and load tests that survive a senior remote technical screen.

14 min read · 3 September 2026

Commit ownership in AI pair coding

AI pair coding shifts who is accountable for a commit. A practical contract: prompt hashing, test gates, ownership tags, and review discipline.

14 min read · 31 August 2026

eBPF observability in 2026: what actually works

A practical guide to production eBPF observability and runtime security: kernel requirements, verifier failures, ring buffers, pinning, and how to measure overhead.

14 min read · 9 August 2026

Agents create incidents at 2am

Why autonomous agents that can open, mutate, or page on incidents cause 2am page storms, and how write boundaries and idempotent alerting fix it.

12 min read · 6 August 2026

WASM servers beat containers here

A practical guide to choosing WebAssembly over containers for short-lived, CPU-bound server tasks, with code, failure modes, and a measurement plan.

12 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

MCP servers: the 3 hidden costs nobody quotes

MCP servers are stateful async processes, not stateless APIs. Here are the real cost drivers, failure modes, and how to measure them yourself.

16 min read · 5 August 2026

Kubernetes or Nomad: the real experiment cost split

A practical comparison of Kubernetes and Nomad for GPU training jobs, covering scheduler latency, cost modelling, GPU sharing, and a decision checklist.

11 min read · 3 August 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

Stop guessing tech stacks: validate tools in 2 hours

A repeatable two-hour process for validating an unfamiliar library or service before it reaches production, with concrete checks and exit criteria.

13 min read · 12 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

Always-On vs On-Demand Agents: Real Cost Trade-offs

Always-on containers bill for idle time; on-demand functions bill per invocation. Compare latency, retries, cold starts, and the failure modes that decide which fits.

12 min read · 5 July 2026

CI/CD for Django in 20ms Africa networks

Design a Django CI/CD pipeline for 1-2 vCPU runners, slow links and metered egress: caching, image size, migrations and health checks.

13 min read · 3 July 2026

Stop false positives in CI scanning now

Static ignore files rot as dependencies change. A triage layer between scanners and PR comments filters alerts using live context instead.

14 min read · 3 July 2026

AI chat's hidden WCAG fails

Why AI chat UIs break screen readers: dynamic ARIA roles, focus hijacking, and contrast failures, plus how to test and prevent them.

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

AI revives unloved legacy codebases

A practical stack for maintaining legacy code: static analysis, generated characterization tests, and LLM documentation, with failure modes and a 30-minute first step.

15 min read · 29 June 2026

When flags become experiments

How to run feature flags and A/B tests on a $5 VPS with no data warehouse, using offline-tolerant self-hosted tooling and SMS replies as conversions.

15 min read · 28 June 2026

AWS Local Zones vs LocalStack: AI microservices in

Compare AWS Local Zones and LocalStack for AI microservices: latency, cost, compliance, and a decision framework, plus how to measure p99 at the edge.

14 min read · 28 June 2026

CI/CD pipelines stall with GPU pods: 2026 benchmarks

GPU pods stuck Pending are usually a scheduling or quota problem, not a broken container. Learn how to diagnose node selectors, device plugins and quotas.

13 min read · 28 June 2026

AI agents vs Argo, Tekton: which pipeline heals itself?

How Argo Workflows and Tekton Pipelines differ for automated failure detection and recovery, with working code and failure-mode analysis.

13 min read · 27 June 2026

Claude Code after a year: daily wins

Design an agentic Dependabot patcher that bumps a dependency, runs tests in a container, and opens a PR only when the suite passes.

13 min read · 25 June 2026

Use feature flags to deploy AI models safely

Use feature flags to canary, shadow and roll back AI model changes without redeploys, with code, metrics and failure-mode handling.

15 min read · 20 June 2026

AI interviews break systems: 5 real mistakes in 2026

AI coding assistants assume a standard Docker environment. Here are five failure modes that break builds in CI, with fixes, verification steps, and a checklist.

14 min read · 20 June 2026

Replace .env with these in 2026

Why .env files fail in production and how managed secret stores, vault agents and encrypted-file workflows replace them, with rotation and caching tradeoffs.

15 min read · 18 June 2026

Code AI won’t rewrite

How to use static analysis, a local LLM, and a structured prompt to map, test, and safely refactor legacy code without inventing risk.

12 min read · 18 June 2026

Resize Images at the Edge: A CloudFront and Lambda Guide

Build an on-the-fly image resizing pipeline with CloudFront, Lambda@Edge, S3 and Terraform, including streaming, format negotiation and observability.

13 min read · 18 June 2026

A Solo-Project Deploy Pipeline That Stays Under $20/Month

Build a test-and-deploy pipeline with GitHub Actions and a container host, then measure cost, cold start, and rollback time yourself.

16 min read · 15 June 2026

Pricing SaaS tools by real cost, not seat count

A practical method for pricing usage-based SaaS: instrument cost per request, model support burden, guard free tiers, and replay traffic before publishing.

13 min read · 15 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

Container Build Caching: What Actually Speeds Up CI

How container build caching works, why cache keys invalidate, and how to measure hit rate and cost before choosing a cache backend.

13 min read · 14 June 2026

Remote work in 2026: which tools still hold up

Design a remote engineering stack for high-latency, metered, outage-prone networks: self-hosted runners, async chat, retries, and observability.

11 min read · 13 June 2026

Context-aware security gates that cut CI alert noise

How to filter CI security findings by pull request diff so scanners surface only what the change actually affects, with policy-as-code examples.

12 min read · 12 June 2026

Personal AI assistants: avoid vendor lock-in traps

How to structure a personal AI assistant as replaceable services: contracts, self-hosted embeddings, retries, failure modes, and a checklist to start.

15 min read · 11 June 2026