Devansh Sahney

I build systems that stay correct when they fail.

Final-year engineering student at NIT Delhi, working mostly in Go on the parts of a system that have to keep their promises under load — queues that execute exactly once, stores that survive contention, pipelines that report on themselves.

1,393/s
job queue throughput
36ms
p99 claim latency
1850+
LeetCode rating

Selected work

Distributed Job Queue Engine

1,393/s
sustained throughput

A job queue that runs every job exactly once, even when workers die mid-execution.

Problem

Workers crash halfway through jobs. Naive queues respond by either dropping that work or running it twice, and both are unacceptable if the job charges a card or sends a message. The queue needs to survive a worker disappearing without a trace.

Decision

Claims go through PostgreSQL's SELECT ... FOR UPDATE SKIP LOCKED rather than a bespoke lock service. That inherits Postgres's crash semantics for free, at the cost of binding throughput to a single database — a ceiling worth accepting for correctness I did not have to prove myself.

Detail
  • 1,393 jobs/sec sustained, 6ms p50 and 36ms p99 claim latency
  • Exactly-once execution via TOCTOU-safe dual-layer idempotency
  • Failed work lands in an in-table dead-letter queue instead of vanishing
  • Crash recovery verified across 10,000 jobs with testcontainers-go
Built with
  • Golang
  • PostgreSQL
  • gRPC
  • Docker
  • Prometheus
  • Grafana

Lightweight In-Memory Key-Value Store

32
independent shards

A Redis-compatible store written from the socket up, with no dependencies.

Problem

A single mutex around a hash map is correct and also useless under concurrent load — every core queues behind one lock. The interesting problem is keeping that correctness while letting readers proceed in parallel.

Decision

Storage is split across 32 independent shards by FNV-1a hash, each with its own sync.RWMutex, so contention is proportional to key collisions rather than total traffic. Sharding gives up cheap cross-key atomic operations, which this store does not promise anyway.

Detail
  • Custom recursive-descent RESP parser with buffered I/O to cut syscall overhead
  • 32-shard storage engine removes global lock contention
  • O(1) LRU eviction through an intrusive doubly-linked list, avoiding boxing
  • Non-blocking dual-layer TTL expiry, so expired keys never leak
Built with
  • Golang
  • Raw TCP sockets
  • RESP protocol

Autonomous GraphRAG & Data Pipeline

A retrieval pipeline that answers questions needing several hops through a graph.

Problem

Vector search returns passages that look relevant individually but cannot answer a question requiring three connected facts. Multi-hop questions need the relationships kept, not flattened into embeddings.

Decision

Relationships live in Neo4j and traversal is driven by a multi-agent reasoning loop, with rule-based guardrails deciding when to stop. The guardrails cost flexibility on unusual queries, which is the trade I wanted against confident wrong answers.

Detail
  • Resolves multi-hop analytical queries a flat vector index cannot
  • Rule-based guardrails constrain the agent loop to cut hallucinations
  • Shipped as a containerised FastAPI service
  • Latency and answer-quality metrics tracked in MLflow
Built with
  • Python
  • LangGraph
  • Neo4j
  • FastAPI
  • Docker
  • MLflow

Background

National Institute of Technology Delhi
B.Tech, Electrical Engineering
Aug 2023 — May 2027 — CGPA 7.83

Certification

  • Deep Learning Specialization — DeepLearning.AI on Coursera

Tools

Languages
  • Golang
  • C/C++
  • Python
  • SQL
Systems & cloud
  • gRPC
  • Apache Kafka
  • Docker
  • AWS EC2 / RDS / S3
  • REST
Data
  • PostgreSQL
  • Redis
  • Neo4j
  • Vector databases
Operating
  • Prometheus
  • Grafana
  • MLflow
  • CI/CD
  • Integration testing

Contests

  • 698
    Global rank, LeetCode Weekly Contest 506
    Rating 1850+
  • Top 60
    Deloitte Hacksplosion 2026
    Shortlisted for round 3, nationally
  • Top 65
    CodeSlayer 2k25, NIT Delhi
    From 10,541 participants
  • Finalist
    Hackfinix 2026
    National finalist
  • Pre-final
    Flipkart GRiD 8.0
    Software development track