Lab

What I build on my own time and my own AWS account. Every project carries its real status: what has run, what is code-complete, and what was a learning exercise.

AI InfrastructurePersonal Project: GPU Inference Lab · Nov 2025 - Present

GPU Inference Platform on AWS EKS

Context

An LLM inference lab on AWS EKS that I am building to measure what self-hosted serving costs and how it behaves on spot GPUs. The first GPU session is still to come. It runs in short burst sessions on my own AWS account and is torn down the same day. It started as a multi-cloud MLOps platform; I cut it back to AWS and LLM inference when the multi-cloud surface turned out to be unverified (ADR-017).

Problem

Teams adopting self-hosted LLMs rarely know what serving actually costs per token on the hardware they can get, or how it behaves when spot capacity disappears. I wanted measured answers, not vendor numbers.

Approach

A small, reproducible platform: Karpenter-provisioned spot A10G nodes, vLLM on KServe, GPU and request telemetry, and a signed, policy-enforced supply chain, rebuilt from empty state for each session.

Inference Engine
vLLM with an OpenAI-compatible API and continuous batching; bf16 and AWQ 4-bit variants of the same 7B model to measure what quantisation buys on an A10G
Over: TGI or Triton Inference Server
Why: OpenAI-compatible API and continuous batching out of the box; the bf16 vs AWQ comparison is the measurement, not an assumption
Model Serving
KServe in RawDeployment mode, with post-deploy verification and metric-gated rollback
Over: Knative serverless mode for canary traffic splitting and scale-to-zero
Why: Simpler operations; I proved live that canaryTrafficPercent is ignored in RawDeployment (ADR-016), so rollback is driven by an error-rate analysis instead of a traffic split
GPU Cost
Spot A10G only, with Karpenter limits, consolidation and a 4-hour expiry; budgets and a daily idle guard on the account
Over: On-demand or reserved GPU instances
Why: Lowest cost per GPU-hour for short sessions; accepted spot interruptions, which are part of what is being measured
Supply Chain
SHA-pinned CI, cosign-signed images verified at admission by Kyverno, hashed lockfiles with drift checks
Over: Trusting registry tags and unpinned dependencies
Why: More moving parts in CI; every first-party image that runs is traceable to a reviewed commit

My role

Designed and built it end to end: Terraform for EKS and the GPU pool, the serving path, CI/CD with OIDC, the admission policies, the teardown tooling, and the runbooks. The July 2026 deployment and its green rebuild surfaced 38 defects (34, then 4 more), all fixed through the pipeline and written up as a retrospective.

Serving Loop
sklearn/MLServer loop end to end on EKS, July 2026 (38 defects fixed)
Rollback
Metric-gated, demonstrated live
Burst Session
One clean cycle, Nov 2026: deploy 33 min, teardown 12.5 min
GPU Benchmarks
Not published yet
AWS EKSKarpentervLLMKServeTerraformKyvernoArgoCDPrometheusGrafanaSource and runbooks

Earlier projects

Learning projects and prototypes, kept for what they taught me.

Archived learning project

Kortex

Learning project (Dec 2025): an LLM API gateway operator in Go (Kubebuilder) that routes OpenAI-compatible requests to hosted providers, with CRD-driven routes, A/B experiments, circuit breakers, retries, rate limiting and cost tracking. Never run against production traffic and not benchmarked. Building it taught me what an LLM gateway has to get right; in practice I run LiteLLM for provider routing, and for in-cluster model routing I would use the Gateway API Inference Extension rather than my own router.

Progress

  • CRDs
  • Routing
  • A/B Testing
  • Fallbacks
  • Metrics
  • Rate Limiting
  • Cost Tracking
  • OpenTelemetry
  • Smart Routing
  • Circuit Breakers
  • E2E Tests
  • not done:Helm Chart
GoKubebuilderKubernetesKServeOpenTelemetryPrometheus
Source on GitHub
Code-complete, not yet run on a GPU

AI Infrastructure FinOps Platform

Prototype (Dec 2025 - Jan 2026) that joins OpenCost allocation with NVIDIA DCGM GPU metrics to attribute GPU cost, with budget alerts, anomaly detection and right-sizing on top. Code-complete with tests and CI, but its DCGM queries have not yet run against a real GPU. Next step: run it during the GPU inference lab sessions and publish measured GPU-hour cost and idle time.

Progress

  • MVP
  • Budget & Alerts
  • ML Analytics
  • Chargeback Reports
  • AWS Billing API
  • Right-Sizing Engine
  • not done:Run on a real GPU
NVIDIA DCGMOpenCostPrometheusGrafanaPython/FlaskThanosAlertmanager
Source on GitHub