Shivam Kachhadiya | Systems & Software Engineer | C++ · Linux · HFT

// 02

Where I Fit

Systems depth + software breadth. Versatile across engineering roles that demand correctness and performance.

Systems & Backend Engineering

Linux, POSIX, C++ concurrency, high-throughput services, TCP/IP networking. Ready for infrastructure, platform, and systems software roles at companies like Google, Meta, Amazon, Akamai, Cisco.

C++LinuxConcurrencyNetworking

HFT & Quantitative Engineering

Order matching engines at 1M+ ops/sec, lock-free SPSC ring buffers at 20M msg/sec, sub-μs latency. Deep understanding of exchange microstructure, price-time priority, and latency profiling.

C++20Lock-FreeHFTLow-Latency

FinTech & Investment Banking

Production Java backends with PESSIMISTIC_WRITE locking for race-safe order management. Real-time price feeds. JWT auth. Factory Pattern dispatch. Targeting JPMC, Morgan Stanley, Goldman Sachs technology divisions.

Java 25Spring BootMySQLFintech Backend

Software Engineering (FAANG / MAANG)

500+ DSA problems, strong OOP & SOLID fundamentals, 13 design patterns implemented in C++, LLD machine coding (BookMyShow, Rate Limiter, Payment Gateway). Ready for SWE interviews and IC roles.

DSALLDSystem DesignOOP

// 03

By the Numbers

1M+

Orders / Second

Exchange-grade order matching engine. O(1) insert, cancel & execute. Price-time FIFO. Stress-tested at 1M+ concurrent orders.

20M+

Messages / Second

Lock-free SPSC ring buffer. Cache-line aligned. ~15–25× faster than mutex baseline. Zero heap alloc in hot path.

500+

DSA Problems Solved

LeetCode + GeeksforGeeks. Trees, Graphs, DP, Greedy, Backtracking, Sliding Window, Binary Search.

370

AIR — VITMEE 2025

All India Rank in the national CS postgraduate entrance exam. Top percentile.

// 04

Engineering Projects

Production-grade systems built from first principles. Every number is benchmarked, every design decision is deliberate.

HFT INFRASTRUCTURE · C++17 · MULTITHREADING · OOP

High-Frequency Order Matching Engine

C++17 OOP Multithreading Price-Time Priority Producer–Consumer CMake Low-Latency

Problem Statement

Financial exchanges require an order book capable of processing millions of orders per second with microsecond-level latency, correct price-time FIFO matching, and no data races under concurrent producer–consumer threads.

System Architecture

┌──────────────────────────────────────────────────────────────────┐
│                    ORDER MATCHING ENGINE                          │
├─────────────────┬────────────────────────────┬───────────────────┤
│   FEED HANDLER  │        ORDER BOOK          │  MATCHING ENGINE  │
│                 │                            │                   │
│  Producer       │  BUY SIDE  (Descending)    │  Consumer         │
│  Thread(s)      │  ┌──────────────────────┐  │  Thread           │
│                 │  │ [100.50] → [Q1][Q2]  │  │                   │
│  → thread-safe  │  │ [100.45] → [Q3]      │  │  match()          │
│    order queue  │  ├──────────────────────┤  │  → execute trade  │
│                 │  │ SELL SIDE (Ascending) │  │  → emit confirm   │
│  unordered_map  │  │ [100.55] → [Q4]      │  │                   │
│  + deque        │  │ [100.60] → [Q5][Q6]  │  │  O(1) per level   │
│  O(1) ops       │  └──────────────────────┘  │                   │
└─────────────────┴────────────────────────────┴───────────────────┘

Key Design Decisions

unordered_map<price, deque<Order>> per side — O(1) insert, O(1) cancel, O(1) execute. No heap allocation in the hot path.
Price-time (FIFO) priority within each price level — semantically identical to real exchange order books.
Producer–consumer pipeline with explicit thread synchronization — demonstrates understanding of concurrent system correctness and debugging under race conditions.
Extensible OOP hierarchy — order types (GTC, IOC, FOK), sides, and matching algorithms cleanly separated behind interfaces. SOLID-compliant.

Performance & Testing

100K – 1M+ orders/sec Microsecond avg latency O(1) insert / cancel / execute 1M+ concurrent orders stress-tested Zero hot-path heap allocation

GitHub GitLab

LOCK-FREE SYSTEMS · C++20 · ATOMICS

Lock-Free SPSC Messaging Framework

C++20 std::atomic Cache-Line Alignment Acquire-Release Zero-Copy TSan / ASan verified

Architecture

Producer           Ring Buffer            Consumer
   │                                          │
   │  write_idx ──→ [ ][ ][ ][ ][ ] ←── read_idx
   │  alignas(64)   preallocated     alignas(64)
   │                  slots                   │
   └──── acquire/release — no mutex ──────────┘
             zero heap alloc in hot path

Key Decisions

alignas(64) cache-line padding on indices — eliminates false sharing.
Acquire-release ordering — correct on x86 & ARM without seq_cst overhead.
Zero-copy preallocated slots — no heap alloc in hot path.
Validated under ThreadSanitizer & AddressSanitizer.

10–20M+ msg/sec Sub-μs median latency ~15–25× vs mutex

GitHub

C++20 · TCP SOCKETS · CONCURRENCY · IN PROGRESS

In-Memory Key-Value Store [Redis-lite]

C++20 TCP Sockets Sharded Locking LRU Eviction TTL Expiry

TCP-based key-value server supporting concurrent GET / SET / DEL / EXPIRE over a custom text protocol. Implements TTL-based expiry, LRU eviction, and sharded locking to reduce contention under high concurrency. Architecture mirrors Redis internals for educational depth.

50K+ ops/sec target Sharded locking LRU + TTL eviction

⬤ Active development

FINTECH BACKEND · JAVA 25 · SPRING BOOT 3.5 · JPMC / IB RELEVANT

TradeShield — High-Concurrency Order Management & Risk Validation Engine

Java 25 Spring Boot 3.5 MySQL / JPA JWT Auth Finnhub API Factory Pattern PESSIMISTIC_WRITE

Problem & Why It Matters

In financial order management (investment banking, brokerages, OMS), concurrent order placements must never corrupt account balances or create phantom positions. Standard optimistic locking is insufficient when correctness is non-negotiable. This system solves that with database-level PESSIMISTIC_WRITE locking on account rows.

Key Design Decisions

PESSIMISTIC_WRITE locks on account rows — eliminates race conditions under concurrent order placement at the DB level.
Finnhub API integration — real-time price validation on every order prevents stale-price manipulation.
Factory Pattern for order-type dispatch — market, limit, stop orders handled cleanly without conditional chains.
Stateless JWT authentication with global exception handling — production-grade security without session state.

PESSIMISTIC_WRITE locking Race-condition free Real-time price feed Stateless JWT auth Factory Pattern dispatch

View on GitHub

C++ · OOP · SOLID · DESIGN PATTERNS · FAANG INTERVIEW RELEVANT

Low-Level Design Systems & 13 Design Patterns

C++ OOP SOLID 13 Design Patterns Machine Coding Thread Safety

Coverage

13 core design patterns in C++: Singleton, Factory, Strategy, Observer, State, Decorator, Command, Adapter, Facade, Builder, Proxy, Chain of Responsibility, Composite.
Machine-coding systems: Payment Gateway (Strategy + Factory + Observer), BookMyShow (concurrent seat booking with mutex locking), Parking Lot, Rate Limiter (Token Bucket & Leaky Bucket).
Real-world system designs: Zomato delivery platform, Google Docs collaboration model, Notification Engine with multi-channel dispatch.
All implementations are thread-safe, SOLID-compliant, and designed for extension without modification.

View on GitHub

// 05

Technical Stack

Core Languages

C++17 C++20 C Java 25 JavaScript SQL PHP

Concurrency & Memory

std::atomic Lock-Free Multithreading Mutexes / CVars Cache-Line Alignment Memory Ordering

Systems & Linux

Linux / POSIX Processes / Threads IPC / Signals Fork / Exec File Descriptors Memory Management

Backend & Frameworks

Spring Boot 3.5 MySQL / JPA REST APIs JWT ReactJS

Design & Architecture

OOP SOLID LLD (13 Patterns) HLD Caching / Sharding Consistent Hashing

Tools & Debugging

Git / GitHub CMake Docker GDB ASan / TSan Wireshark VS MSVC

// 06

Education

cat education.log

[2025–Now] M.Tech, Computer Science & Engineering — VIT Vellore, Tamil Nadu | CGPA: 8.65 ACTIVE
[2023–2025] MCA — SRM Institute of Science & Technology, Chennai | CGPA: 9.26 COMPLETED
[2020–2023] BCA — Atmiya University, Rajkot, Gujarat | CGPA: 8.89 GRADUATED

cat certifications.log

[C++17/20] Modern C++ Certification — Concurrency, move semantics, RAII, smart pointers, template metaprogramming VERIFIED
[SWE] Software Engineering — HackerRank — Algorithms, data structures, REST API design, DB models VERIFIED
[DSA] 500+ Problems Solved — LeetCode + GFG. Trees, Graphs, DP, Greedy, Backtracking, Binary Search, Sliding Window ACTIVE

// 07

GitHub Activity

An engineering record built in public — systems, algorithms, LLD, and backend work all open-sourced.

75+

Public Repositories

HFT systems, lock-free concurrency, LLD design patterns, OS internals, DSA practice, and Java backends — all open source.

C++ / Java

Primary Languages

Systems-level C++17/20 for performance-critical code. Java 25 + Spring Boot for production backend services.

Active

Consistent Commits

Regular commits across systems projects, LLD implementations, and DSA practice. A living engineering record.

github.com/shivamkachhadiya gitlab.com/shivamkachhadiya

// DSA JOURNEY

LeetCode & DSA Practice

Consistent algorithmic problem solving since 2023. Interview-ready depth across all major topics.

500+

Problems Solved

LeetCode + GeeksforGeeks. Consistent since 2023.

@shivamkachhadiya

topics --covered

Graphs Trees Dynamic Programming Greedy Backtracking Sliding Window Two Pointers Binary Search Heap / Priority Queue Stack & Queue Linked Lists Recursion

Shivam Kachhadiya – Systems & Software Engineer | C++ | Linux | HFT | Backend | FAANG

Building software where correctness and performance both matter.

About Me