I work across the whole surface of the project rather than one corner of it — the Go server, the mesheryctl CLI, the React UI, and the Hugo documentation site. Every contribution follows the same loop: reproduce, bisect, root-cause, then fix the cause instead of the symptom.

      
^{Layer5 Recognition Program}

The fix is usually small. Finding out which line actually deserves the fix is the work.

Three examples, all from the ledger above:

A regression that wasn't where it looked. Settings tabs broke and two E2E tests started failing alongside them. The obvious move is to patch the visible symptom. Instead I walked the history backwards through several merge commits until the cause resolved to a single dropped import, then fixed that and verified the tests end to end.

A filter the backend already supported. component search and component list both hit the same registry endpoint, but the handler never read a model query parameter — even though ComponentFilter.ModelName already existed and was being used by a neighbouring route. The CLI flag was the visible half; the real fix was three lines in the Go handler.

An icon that was already declared. A wizard step was rendering a generic document icon instead of a gear. The step definition already set icon: SettingsIcon — the modal was simply deriving its steps from an array of label strings rather than the step objects themselves, discarding the field. The sibling modal in the same directory already did this correctly, so the fix was to stop inventing a convention and match the one already shipped.

The pattern in all three: the interesting question is never what broke. It's which layer owns the breakage.

Reading about LSM-trees teaches you the diagram. It does not teach you what happens when a flush races a read, or what the log has to contain for a crash mid-write to be recoverable. So I built the engine instead.

An embedded key-value storage engine written from scratch, implementing the Log-Structured Merge-Tree architecture behind LevelDB and RocksDB.

     put()                          get()
       │                              │
       ▼                              ▼
   ┌───────┐   append-first    ┌─────────────┐
   │  WAL  │◄──────────────────│   MemTable  │  shared_mutex:
   └───────┘   ack on append   └─────────────┘  N readers ‖ 1 writer
                                      │ flush
                                      ▼
                               ┌─────────────┐
                               │  SSTable L0 │──┐
                               └─────────────┘  │ leveled
                               ┌─────────────┐  │ compaction
                               │  SSTable L1 │◄─┘
                               └─────────────┘
                                      ▲
                               Bloom filters cut
                               the miss path

• Thread-safe MemTable via std::shared_mutex — concurrent readers proceed in parallel while writers take exclusive access
• Write-Ahead Logging that acknowledges after the WAL append rather than after the flush: durability without paying disk latency on every put
• Background compaction engine performing leveled SSTable merging
• Bloom filters to cut unnecessary disk reads on lookups

C++17 · Concurrency · Write-Ahead Logging · Storage Internals

A naïve video analytics service couples capture to inference — the moment the GPU falls behind the camera, frames are silently dropped and the detection record becomes a lie.

An event-driven microservice pipeline that decouples edge ingestion from neural network compute through Kafka, so backpressure lands in a durable log instead of in the capture loop.

• Zero frames dropped at peak backpressure
• −80% CPU load via smart frame sampling, without losing detection continuity
• Headless YOLOv8 inference nodes as Kafka consumers — throughput scales by adding consumers, not by rewriting the pipeline
• Docker Compose with dependency healthchecks across Zookeeper, Kafka and PostgreSQL

FastAPI · Apache Kafka · YOLOv8 · PostgreSQL · Docker

Real-time parking slot detection from live video feeds, with a web interface for availability and navigation.

YOLOv8 · OpenCV · Flask

Languages

Cloud Native & Infrastructure

Systems & Low-Level

Backend, Web & ML

I like the parts of software that have no UI.

Most of my time goes into the layer where correctness is non-negotiable: write-ahead logs that survive a crash mid-flush, consumers that keep up when the producer refuses to slow down, locks that let a hundred readers through without letting one writer corrupt the page. I started there because it was the part I could not fake my way through.

CS undergraduate at DSCE Bangalore · CGPA 8.2 / 10.0 · Graduating July 2028 Focused on distributed systems, storage internals and microservices.

Under a clock

Certifications & communities — Certified Meshery Contributor (CNCF) · Build an AI Agent with Agentforce (Salesforce) · Technology Job Simulation (Deloitte Australia, Forage) · Microsoft Student Ambassador · AWS Student Builder Club, DSCE