Govind
Open to senior backend / systems roles

Govind

Backend & Systems Engineer

I design, build and operate the parts of software you don't see: APIs, data planes, storage engines and the infrastructure underneath. Twelve years of shipping services that stay up, stay fast, and stay cheap to run.

role
backend / systems
base
Remote · UTC+05:30
uptime
12+ yrs in production
core
go · rust · postgres · kubernetes
browse work résumé pdf

Projects

all projects ↗

    flywheel(opens on GitHub)

    distributed job scheduler

    Fault-tolerant scheduler built on a hand-rolled Raft implementation: leader election, log replication, and at-least-once dispatch with idempotency keys. Cron expressions and DAG dependencies included, because every team eventually reinvents Airflow badly.

    1.2M jobs/day on a 3-node cluster, p99 dispatch < 80ms

    • rust
    • raft
    • grpc
    • sqlite
    repo ↗(opens in new tab) write-up →

    cask(opens on GitHub)

    append-only key-value store

    Bitcask-style storage engine: an in-memory hash index over append-only segment files. Recovers from kill -9 at any write boundary, merges segments in the background, and never mutates a byte in place.

    120k ops/s single node, p99 read < 600µs, 8GB dataset

    • go
    • storage-engine
    • crash-recovery
    repo ↗(opens in new tab)

    tailpipe(opens on GitHub)

    log ingestion pipeline

    Kafka → ClickHouse pipeline with size- and time-based batching, backpressure propagated end to end, and a dead-letter queue with replay. Rewriting the flush path cut daily part count 4x and made midnight merges boring.

    1M events/s on 3 nodes, end-to-end lag < 2s at peak

    • go
    • kafka
    • clickhouse
    • otel
    repo ↗(opens in new tab) write-up →

Experience

Senior Backend Engineer

2022 — now

Meridian Pay · remote

  • Rewrote the ledger service from synchronous Postgres writes to an event-sourced design: p99 write latency 240ms → 38ms, and month-end reconciliation runs stopped timing out.
  • Cut Kafka consumer lag SLO breaches by 92% by replacing per-message offset commits with size- and time-batched commits.
  • Built the shadow-traffic load-testing harness (k6 + production replay); capacity reviews went from a two-week scramble to a two-hour exercise.
  • On-call for 14 services. Wrote 30+ runbooks; median MTTR for paged incidents dropped 45min → 12min.
  • go
  • postgres
  • kafka
  • kubernetes
  • terraform

Backend Engineer

2019 — 2022

Warpframe Hosting · hybrid

  • Owned the metadata plane for object storage: 4B objects, 300k req/s at peak, and one full region evacuation handled without a status-page incident.
  • Migrated 9TB of MySQL to Postgres with under 30s of write downtime using logical replication and a read-only drain window.
  • Introduced gRPC for internal calls and deleted three REST hop layers; internal p95 dropped 60ms purely from removing serialization overhead.
  • go
  • mysql
  • postgres
  • prometheus
  • linux

Software Engineer

2014 — 2019

Cloudline Systems · on-site

  • Wrote the usage-metering and billing pipeline that processed $40M/yr of events with exactly-once semantics and a replay path for every failure mode we could imagine (and three we couldn't).
  • Replaced hand-run deploys with the company's first automated pipeline (Ansible + blue/green), cutting release day from 6 hours to 20 minutes.
  • Shipped and maintained the on-prem installer used by 200+ enterprise customers, including the upgrade path nobody wanted to own.
  • python
  • mysql
  • redis
  • ansible
  • linux

Writing

all posts ↗
  1. I wrote Raft from scratch and spent a month losing electionsA three-node cluster that changed leaders every 90 seconds, and the one-line bug behind it.2 min read →
  2. A 40% CPU regression, found with perf and one bad assumptionThe faster hash function was slower. Here's how perf proved it in about twenty minutes.2 min read →
  3. What VACUUM taught me about batching writesPostgres's janitor is a design review for your write path, if you bother to read its complaints.1 min read →

About

I'm Govind — a backend and systems engineer. For twelve years I've been the person teams call when a service falls over at 3am, or when something that worked fine at 1x traffic has to work at 50x.

Most of my work lives where software meets the machine: storage engines, schedulers, ingestion pipelines — the unglamorous plumbing that everything else assumes will hold. I like systems you can reason about: small interfaces, explicit failure modes, boring on-call.

Off the clock I break things on purpose. The projects on this site are mostly excuses to learn how databases, consensus protocols and kernels actually behave under load — and I write about what I find.

// now

  • Building flywheel, a distributed scheduler that exists mostly to teach me Raft.
  • Learning eBPF by tracing syscalls I do not fully understand yet.
  • Migrating the homelab off duct tape, one Ansible role at a time.

// languages

  • Go
  • Rust
  • Python
  • SQL
  • TypeScript
  • Bash

// systems & data

  • PostgreSQL
  • Redis
  • Kafka
  • ClickHouse
  • etcd
  • NATS
  • SQLite

// infrastructure

  • Kubernetes
  • Docker
  • Terraform
  • Linux
  • systemd
  • eBPF
  • AWS
  • GCP

// observability

  • Prometheus
  • Grafana
  • OpenTelemetry
  • pprof
  • perf

Contact

Open to senior backend and systems roles. If you're hiring — or just want to argue about log-structured storage — my inbox is open.

hello@govind.dev