Thread 03 — Others
Systems, markets
& pipelines.
The rest of the stack I care about — scalable system design, low-latency trading systems, and the MLOps that carries a model from notebook to production and keeps it honest there.
Three threads
System Design
Designing systems that scale — partitioning, caching, and the consistency trade-offs behind them.
- Horizontal scaling & sharding
- Caching + CDN strategy
- Message queues (Kafka)
- CAP & consistency trade-offs
HFT / Low-Latency
Trading systems where microseconds matter — from the order book down to cache lines.
- Limit order book & matching
- Lock-free data structures
- Market-data ingestion
- Backtesting & risk checks
MLOps
The distance between a notebook and production — automated, versioned, and observable.
- Experiment tracking & model registry
- Reproducible pipelines (DVC + CI)
- Eval gates before promotion
- Drift & latency monitoring
MLOps
A model isn't done when it trains.
The six stages that turn a notebook result into something a team can ship, trust, and roll back — each one automated, or it doesn't hold.
Version
Data, code, and weights move together. DVC + Git so any model in production traces back to one commit, one dataset hash, one seed.
Track
Every run logs params, metrics, and artifacts — no results living in a notebook cell. The registry is the single source of truth for what is staged and what is live.
Automate
Pipelines as code, not as a runbook. Scheduled retraining and a CI job that reruns the whole thing on every PR, so the training path never rots.
Gate
Nothing ships on accuracy alone. Eval suites, regression baselines against the incumbent, and slice metrics block a promotion before users ever see it.
Serve
Containerized inference behind a versioned API — quantized or ONNX-compiled where latency matters, with canary rollout and a one-command rollback.
Watch
Drift, data quality, latency, and cost on one board. Alerts wired to a retraining trigger, so the loop closes instead of ending at a dashboard.
Toolkit
System design
Architecture, cached with Redis.
1class="syntax-comment"># Cache-aside read-through with Redis2import json3import redis4 5cache = redis.Redis(host="localhost", port=6379, decode_responses=True)6TTL = 300 class="syntax-comment"># seconds7 8def get_user(user_id: str) -> dict:9 key = f"user:{user_id}"10 cached = cache.get(key)11 if cached:12 return json.loads(cached) class="syntax-comment"># cache hit13 14 user = db.fetch_user(user_id) class="syntax-comment"># miss -> source of truth15 cache.set(key, json.dumps(user), ex=TTL) class="syntax-comment"># populate cache16 return user17 18def invalidate(user_id: str) -> None:19 cache.delete(f"user:{user_id}") class="syntax-comment"># write-through invalidationSelected work
2 projectsFocus
Distributed Systems
Sharding, replication, consensus, CAP trade-offs.
Low-Latency
Lock-free structures, cache-aware code, kernel bypass.
Model Delivery
Registry, eval gates, and reproducible one-command rollouts.
Observability
Metrics, tracing, drift detection, and SLOs on live models.