kailash(1) — Kailash Yadav, Software Engineer

NAME

Kailash Yadav kailash — software engineer; builds durable, event-driven systems and the tools that keep them honest

SYNOPSIS

kailash [-l python|go|typescript] [-i kubernetes|docker|helm]
        [-d distributed-systems|workflow|storage|networking|hardware]
        [-v] <problem>

kailash --ship [--from-scratch] [--on-call] <product>

DESCRIPTION

kailash takes a system that has to keep its promises while things fail underneath it, and makes it do that. Eight years of it: first validating the server hardware that cloud regions are built from, then the control planes that orchestrate storage and recover from failure, and now the workflow engine that drives cloud-savings automation at IBM Apptio Cloudability.

The common thread is durable execution — state that survives a restart, retries that are safe to run twice, and a log you can read afterwards to find out what actually happened. Started close to the metal, which is why the distributed parts don't feel like magic.

Off the clock, kailash ships developer tools: a drill CLI that quizzes you on your own code, a daily digest that is immutable by database trigger, and a catalogue of engineering practices for teams where most of the code is now written by a model.

OPTIONS

-l, --lang lang: Python for anything that has to be readable a year later. Go when it should be one binary with no runtime. TypeScript when there is a UI attached. C and shell when the machine insists.
-d, --domain domain: Workflow orchestration and durable execution, distributed systems, object storage, networking, BMC and server hardware, developer tooling.
-i, --infra target: Kubernetes (Helm, StatefulSets, operators), Docker, Postgres, SQLite, REST and event-driven interfaces, DMTF Redfish for anything with a baseboard management controller.
--ship: Takes a thing to production rather than to a demo: migrations, rollout, dashboards, the pager rotation, and the postmortem when it still goes wrong.
-v, --verbose: Will explain why at-least-once delivery is fine, or the rope data structure behind Edituh, entirely unprompted. Repeat for diagrams.

HISTORY

Eight years, newest first. Click a commit to see the diff.

$ git log --graph --decorate --stat career.git

*
IBM · Apptio Cloudability Software Engineer 2024-05 → present
- diff --git a/cloudability b/cloudability
- Building the workflow orchestrator at the center of an event-driven execution system — the Temporal-shaped problem: workflow definitions, activity dispatch, retry and backoff policy, timers, and state checkpointed so a run survives a process restart and resumes instead of starting over.
- Made at-least-once delivery safe for actions that move real money — idempotency keys, deduplication, and exactly-once side effects for savings automation that resizes, schedules and commits customer cloud spend.
- Designed for operators, not just for the happy path: every run is inspectable, replayable, and cancellable, so support can answer "what did it do to my account at 3am" from the event log rather than from a guess.
- Pulled into customer deep-dives and proofs of concept, turning "can it handle our approval flow?" into a working demo — work that contributed directly to closing deals.
4 files changed, 1842 insertions(+)

Durable execution Event-driven Distributed systems FinOps Kubernetes
*
MSys Technologies (now Aziro) · for Cisco Senior Software Engineer 2021-08 → 2024-05
- diff --git a/self-healing b/self-healing
- Worked on a platform that detects a failure in a running system, classifies it, and executes the correction itself — signal ingestion, diagnosis, remediation playbooks, and verification that the fix actually took.
- Guardrails are the hard part of automated remediation: bounded retries, blast-radius limits, a circuit breaker when the same fault keeps recurring, and an audit trail for every action taken without a human in the loop.
- Shrank the set of alerts that need a person — the operator reads what was corrected instead of correcting it.
3 files changed, 976 insertions(+)

Python Automated remediation Observability Reliability
*
MSys Technologies · for Seagate 2022 → 2024
- diff --git a/cortx b/cortx
- Provisioning and orchestration for CORTX, Seagate's S3-compatible object store — the MinIO-shaped problem at exabyte ambitions, deployed onto Kubernetes.
- Helm-packaged control and data planes: StatefulSets for the nodes that own durable state, config and secret wiring, storage-class and device mapping, ordered bring-up, and rolling upgrades that don't drop the data path.
- Turned a hand-run bring-up runbook into a repeatable deploy — a cluster from nothing in minutes, the same way every time, which is what made the test and demo cycle usable.
2 files changed, 1134 insertions(+)

Kubernetes Helm Object storage S3 Python
*
MSys Technologies internal libraries 2021 → 2024
- diff --git a/lib b/lib
- A key-value store used as the control plane's source of truth, with watch semantics so services react to a config change instead of polling for one.
- Distributed semaphore locks with leases, TTLs and renewal — caps concurrency on a shared resource and stops two nodes from running the same remediation at the same time. Correct behaviour when the lock holder dies is the whole design.
- An activity-monitor framework for long-running work: heartbeats, deadlines, stuck-task detection and cancellation. Written once, then adopted by the services around it.
3 files changed, 742 insertions(+)

Distributed systems Concurrency Leases & locks Library design
*
Mindtree · for Microsoft Azure Software Engineer 2018-02 → 2021-08
- diff --git a/bmc b/bmc
- Automated the baseboard management controller through the DMTF Redfish API: hardware inventory, firmware update, power and boot control, sensor and telemetry collection, and SEL log capture — all of it out-of-band, with the host down.
- Replaced per-vendor IPMI scripting with one Redfish client that worked across server generations, so a new SKU arriving in the lab was a config entry rather than a rewrite.
- This is the layer where a datacenter stops being an abstraction: if the automation is wrong, somebody walks to the rack.
2 files changed, 688 insertions(+)

Python DMTF Redfish BMC / IPMI REST
*
Mindtree · for Microsoft Azure Cloud Infrastructure 2018 → 2021
- diff --git a/validation b/validation
- Validated the servers and components that Azure regions are built out of, before they reached the fleet: CPUs, memory, disks and NVMe, network cards, storage controllers and expansion devices.
- Functional, stress, burn-in and power-cycle runs; triaged the failures that came out of them with vendors, down to the firmware revision or the errant component.
- Built the automation that turned a manual test pass into a scheduled run across racks, with results that could be compared between hardware revisions instead of retold.
4 files changed, 1420 insertions(+)

Python Hardware validation Test automation Azure
*
Mindtree · server lab 2018 → 2020
- diff --git a/lab b/lab
- Lived in a server lab: racking and cabling, BIOS and firmware levels, network and storage fabric, swapping disks, DIMMs and NICs to reproduce a failure on purpose.
- Learned to read a machine through its logs and its sensors until the root cause stopped being a guess — the habit that everything since has been built on.
1 file changed, 310 insertions(+)

Servers Networking Storage Linux
*
Self-taught pre-2018
- diff --git a/dev/null b/career
- Data structures, algorithms, a packet sniffer written to find out what was actually on the wire, and the first program that did something useful for somebody else.
1 file changed, 1 insertion(+)

EXAMPLES

Things built outside work hours, each one because a tool I wanted didn't exist.

Keep your own code in your head sharp drill

A local CLI that picks a function you wrote, blanks its body or plants a one-token bug in it, and makes you put it back with no AI and no autocomplete — then tracks whether you're getting faster. A card is only offered if your test suite actually catches the edit, so every drill has a real pass/fail oracle. No server, no account, no network call: all state is one SQLite file.

Engineering practices for when the model writes the code ctxc build && i2e run --gate

Twenty-eight proposed practices for teams where most code is written by a model, held as data so the tools and the docs can't drift apart — and working first versions of the four that change the delivery pipeline most: ctxc compiles decision records, incidents and rules into a versioned context artifact and lints it; i2e turns every postmortem into a permanent eval case that gates prompt and model changes; friction charges agent stalls and thrash to the module that caused them; tier derives how much autonomy a change is allowed from its blast radius. Local, zero-dependency Node.

One frozen edition of software news a day npm run daily

A dated daily digest collated from Hacker News, Lobsters, GitHub, arXiv, Reddit and ~90 engineering blogs and changelogs — 19 ranked entries plus a hand-written curriculum unit, about a fifteen-minute read. An edition is frozen when it publishes and never changes again, enforced by Postgres triggers rather than by application code, because a feed that keeps backfilling has no stable yesterday.

A documentation workspace that works offline edituh --desktop

A Confluence/Notion-style documentation editor for web and desktop: math, diagrams, bidirectional links, a knowledge graph and daily notes, on a balanced rope so large documents stay fast to edit. FastAPI and React (BlockNote, Mantine), shipping as desktop installers and a PWA.

Make every engineer's agent follow the same process cp -r skills/ ~/.claude/skills/

A small, composable set of development skills for AI coding agents, built to reduce variance rather than to automate thinking away. The organising principle is that a skill guides and does not enforce, so anything mandatory belongs in CI and the skills cover the judgment-heavy process CI can't check — spec, design, pre-mortem, implement, test, review, ship.

Earlier: go-banking (concurrent-safe transaction API in Go), packet sniffer (raw sockets, one protocol at a time), Echo (Flask micro-blogging), pip2poetry (one less afternoon of manual migration).

ENVIRONMENT

EDITOR: nvim. This page was a Vim-themed portfolio before it grew up into a manual page; the keybindings survived the refactor.
SHELL: zsh and tmux, one window per problem.
PAGER: less -R, which is why j, k, gg and G work here.
OFFLINE: Long drives with no destination, a camera, hardware taken apart on the desk, and a book that isn't about computers.

BUGS

Reaches for a distributed primitive before asking whether one process would have done. Aware of it; still does it.
Will rewrite your build tooling if left unattended for a sprint.
Wants the first version to be right, which costs more than shipping the second version would have. Mitigated, not fixed.
Cannot leave a manual page unread, including this one.

Report bugs to the address in SEE ALSO.