Skip to content
Open to systems / quant-dev roles

I build systems wheremicroseconds and correctnessboth matter.

I write the layer everything else sits on — concurrency, compilers, lock-free data structures, and the network code that ties them together. Today a data engineer; aiming at the hardest problems in low-latency and large-scale data infrastructure.

amogh@systems: ~
❯whoami
amogh ramesh — systems engineer
locationbangalore, india · IST
focuslow-latency · data infra · quant
languagesc++ · rust · go · python
nowdata engineer → quantitative dev
❯
0
LeetCode solved
0
Hard problems solved
0
Upstream OSS projects
0
Systems from scratch
01Selected Work

Things I built from the metal up.

012024
Systems · C++
View source

Tez

An HTTP server in C++, written from sockets up.

A web server built without leaning on a framework — raw sockets, the HTTP/1.1 request lifecycle, and a concurrency model that has to stay correct under simultaneous connections.

The hard part — The problem every production server hides from you: handling many clients at once without races, leaks, or blocking the event path.

  • Full request lifecycle — parse, route, respond — with no external HTTP framework.
  • Concurrent connection handling via a thread-pool model, latency kept flat as connections scale.
  • RAII discipline throughout — manual memory & resource management, no leaks under sustained load.
C++POSIX socketsthread poolHTTP/1.1
022024
Compilers · C++
View source

minilang

A language with a real compiler — lexer to LLVM IR.

A programming language with a complete compiler pipeline: lexing, parsing, AST construction, semantic analysis, and code generation lowered to LLVM IR for a native backend.

The hard part — The whole front-end-to-back-end contract — designing a grammar, building a walkable AST, and emitting IR that LLVM will optimize into machine code.

  • Complete frontend — tokenizer, recursive-descent parser, and a typed AST.
  • LLVM-backed backend lowering the AST to IR; compiles to optimized native code, not interpreted.
  • End-to-end ownership of the toolchain — language design through code generation.
C++LLVMlexer / parserASTIR codegen
032025
Concurrency · Go
Private · guided research

SplitOrderedLists

A lock-free hash table that grows without ever taking a lock.

A lock-free, split-ordered concurrent hash table in Go — based on the Shalev–Shavit design — implemented as a guided study under a supervising professor.

The hard part — Resizing a hash table while many goroutines read and write concurrently, using only atomic compare-and-swap — no mutexes anywhere on the hot path. Get the memory ordering wrong and it corrupts silently under load.

  • Bucket expansion that doubles capacity without rehashing the underlying lock-free list — no stop-the-world resize.
  • Built entirely on atomic primitives (compare-and-swap), correct under high goroutine contention.
  • Benchmarked against mutex-guarded maps — scaling held where the locked baseline degraded.
Goatomic CASlock-freeconcurrent data structures
042026
AI Systems · Python
View source

JARVIS

A personal AI operating system I run my life on.

A self-built AI operating layer — 256+ scripts, 22 MCP servers, a vector-DB memory backbone, Telegram/WhatsApp bridges, and autonomous agents that run on schedules.

The hard part — Orchestration: keeping a fleet of long-lived services, daemons and model calls coherent, recoverable, and sharing one persistent memory across every interface.

  • Unified vector-DB memory shared across terminal, Telegram and WhatsApp — one brain, many front doors.
  • 22 MCP servers and 256+ scripts run as self-healing launchd jobs that survive reboots and token rotations.
  • Hybrid semantic + keyword search over the whole personal corpus — dense vectors + FTS5, fused with RRF.
PythonChromaDBMCPlaunchdDockerLLM orchestration
052025
Full-stack · Infra

Coding-Education Platform

Educative-meets-CodeCrafters with real sandboxed test runners.

A coding-education platform — 23 hands-on challenges and 7 structured courses — with an in-browser Monaco editor and a Dockerized sandbox that compiles and tests submitted code against real suites.

The hard part — Safe execution: running untrusted user code in isolated containers and returning verdicts fast, without letting anyone escape the sandbox.

  • 23 challenges & 7 courses with isolated, per-submission Docker test runners returning pass/fail verdicts.
  • GitHub OAuth and a Monaco-powered IDE experience in the browser.
  • Fully containerized deployment via docker-compose behind Caddy with automatic TLS.
Next.jsMonacoDockerGitHub OAuthCaddy
02Open Source

Upstream, where the review bar is unforgiving.

ApacheRust

DataFusion

A high-performance, extensible query engine. Contributions upstream.

MetaC++

RocksDB

One of the most widely deployed embedded storage engines in production.

RustRust

rust-lang/rust

The Rust toolchain itself — where the review bar is unforgiving.

ApacheRust / Spark

DataFusion Comet

Native acceleration for Apache Spark. Earlier: MindsDB, gemini-cli.

03Stack

The tools I reach for, by layer.

01

Systems & Low-Latency

where my attention lives

  • Modern C++ (STL, RAII)
  • Concurrency & multithreading
  • Lock-free data structures
  • Sockets & network programming
  • Memory management
  • Performance optimization
02

Languages

fluent

  • C++
  • Rust
  • Go
  • Python
  • SQL
03

Compilers & Tooling

end-to-end toolchains

  • LLVM
  • Lexers / parsers
  • AST design
  • IR code generation
  • Language design
04

Data & Distributed Systems

at scale

  • Data pipelines & ETL
  • Distributed systems
  • Query engines (DataFusion)
  • Vector search (ChromaDB)
  • FTS5 / hybrid retrieval
05

Infrastructure & Web

to ship it

  • Docker / compose
  • Caddy
  • launchd orchestration
  • Next.js / React
  • OAuth
  • CI/CD
04About

The throughline

I'm a data engineer who spends his real attention one layer down — on the code that decides whether a system is fast, correct, and able to survive contention.

I've written a concurrent HTTP server in C++ from sockets up, built a small language with an LLVM-backed compiler, and implemented a lock-free split-ordered hash table in Go under a supervising professor. The throughline is the same: I want to understand systems at the level where the tradeoffs are real — memory ordering, cache behaviour, what the scheduler actually does.

That's also why I'm aiming at quantitative development and large-scale data infrastructure — the two places where systems engineering stops being theoretical and starts being measured. I contribute upstream to projects like DataFusion and RocksDB to keep that bar honest, and I grind algorithms to keep the fundamentals sharp.

data engineer → quant dev bangalore · IST
Amogh Ramesh
fig.01 — amogh rameshc++ · rust · go
05Contact

Building something that needs the fast, correct layer?

I'm reachable directly. Cold emails from sharp teams are always welcome.

ramogh2404@gmail.com
GitHub@Amogh-2404LinkedInamogh-rameshLeetCodeAlpha2404CodeforcesAlpha-2404Medium@ramogh2404