Abhishek Kumar — Systems Engineer

01 / SYSTEMS & ARTIFACTS

Featured Engineering Projects

Infrastructure, distributed systems, and AI developer tooling built with deterministic reliability and verifiable performance.

PROJECT 01Go

source code

Distributed Workflow Engine

Fault-tolerant job scheduling with DAG orchestration

A production-grade distributed job scheduler with priority queues, concurrent worker pools, at-least-once delivery, and DAG workflow orchestration — built from scratch in Go.

GoPostgreSQLRedisNext.jsDockerPrometheusGitHub Actions

[Problem Statement]

Modern applications need reliable background job processing that handles failures gracefully. Off-the-shelf solutions often lack fine-grained control over scheduling semantics, retry policies, and dependency-aware execution.

[Engineered Solution]

Built a custom job scheduler in Go with Redis for priority dispatch (using atomic Lua scripts with 6:3:1 weighted scheduling) and PostgreSQL for durable state transitions. DAG workflows use Kahn's algorithm for cycle detection and dependency-aware parallel execution.

Interactive Execution Diagram

Live Execution Trace|Deterministic Engine Simulator

System Nodes & Transition FlowIdle — Ready to Run

N01

Producer

input

N02

Priority Queue

process

N03

Dispatcher

process

N04

Worker Pool

process

N05

PostgreSQL

storage

N06

Retry / Backoff

error

N07

Dead Letter Queue

error

N08

Completion

output

// Click "RUN SIMULATION" to trigger execution stream...STANDBY

Verified Benchmarks:

Zero duplicate claims across 15 workers:Verified✓

Orphan job recovery:<100ms✓

PROJECT 02Python

source code

CodeLens

AI-powered code review platform

A self-hosted GitHub AI code review platform that analyzes pull request diffs using a hybrid AST + semantic retrieval + LLM pipeline for automated security scanning, bug detection, and contextual review.

PythonFastAPINext.jsReactPostgreSQLRedisOpenAI GPT-4o

[Problem Statement]

Manual code review is slow and inconsistent. Existing AI tools often lack context about the codebase, produce noisy results, and don't integrate deeply with GitHub's review workflow.

[Engineered Solution]

Built a hybrid pipeline: deterministic rules (AST analysis + regex) catch known patterns, while semantic retrieval provides codebase context to GPT-4o for nuanced analysis. 8K-token budgeting ensures cost control. HMAC-SHA256 webhook verification, prompt-injection isolation, and encrypted credentials ensure security.

Interactive Execution Diagram

Live Execution Trace|Deterministic Engine Simulator

System Nodes & Transition FlowIdle — Ready to Run

N01

GitHub PR

input

N02

Webhook Handler

process

N03

Diff Extraction

process

N04

AST Analysis

process

N05

Context Retrieval

process

N06

LLM Analysis

process

N07

Severity Filter

process

N08

Review Submission

output

// Click "RUN SIMULATION" to trigger execution stream...STANDBY

PROJECT 03Go

source code

SyncForge

Real-time collaborative document platform

A real-time collaborative document platform with conflict-free state synchronization using a custom RGA CRDT with Lamport timestamps, supporting offline-first editing and deterministic convergence.

GoNext.jsReactPostgreSQLRedisWebSocketsDockerPrometheus

[Problem Statement]

Building real-time collaboration requires solving conflict resolution without a central authority locking mechanism. Traditional OT (Operational Transformation) is complex to implement correctly at scale.

[Engineered Solution]

Implemented a custom RGA (Replicated Growable Array) CRDT with Lamport timestamps for conflict-free synchronization. Combined with WebSocket-based real-time transport, Redis Pub/Sub for presence, and batched persistence to PostgreSQL.

Interactive Execution Diagram

Live Execution Trace|Deterministic Engine Simulator

System Nodes & Transition FlowIdle — Ready to Run

N01

Client A

input

N02

Client B

input

N03

WebSocket Server

process

N04

RGA CRDT Engine

process

N05

Redis Pub/Sub

process

N06

PostgreSQL

storage

N07

Converged State

output

// Click "RUN SIMULATION" to trigger execution stream...STANDBY

Verified Benchmarks:

Throughput under 15 clients:62K+ ops/sec✓

Convergence tests passed:15+✓

02 / ARCHITECTURAL THINKING

How I Approach Engineering Problems

Engineering is the disciplined management of trade-offs. Here is how I think through concurrency, fault tolerance, consistency, and AI pipelines.

Select Architecture Case Study

CONCURRENCY & ATOMICITYDistributed Workflow Engine

Atomic Redis Dispatch vs Distributed Locks

Achieving sub-millisecond priority scheduling with zero race conditions

01 / The Core Challenge

Multiple distributed workers concurrently poll for jobs. Using standard distributed locks introduces high lock contention, latency spikes, and deadlocks if a worker dies while holding a lock.

02 / System Constraints

C0115+ concurrent workers polling continuously

C02Strict weighted priority scheduling (6:3:1 ratio)

C03Zero double-processing or duplicate claims

✓ Architectural Decision

Implemented atomic Redis Lua scripts that inspect priority queues, perform weight-ratio calculations, and dequeue jobs in a single atomic transaction on the Redis server without distributed locking overhead.

⇄ Accepted Trade-Off

Lua scripts execute single-threaded in Redis, meaning slow Lua logic would block the Redis server. Addressed by strictly keeping scripts O(1) in time complexity.

03 / Failure Mode & Recovery Strategy

Visibility timeout watchdog detects unresponsive workers, reclaiming unacknowledged jobs in <100ms.

03 / CAPABILITY MATRIX

Technologies Organized by Engineering Role

No arbitrary percentage bars or laundry lists. Here is how my toolset maps directly to shipped production infrastructure.

BUILD

Languages & frameworks I ship production code in

SCALE

Infrastructure for reliable, concurrent systems

SHIP

Tools that get code to production

THINK

Fundamentals that inform every decision

AUGMENT

AI & intelligent systems engineering

Technology Inspector

[HOVER OR TAP A SKILL]

Inspect which real projects and architectures utilize that technology.

04 / VERIFIABLE TRACK RECORD

Proof of Work & Competitive Benchmarks

Direct links to verified profiles, competitive programming statistics, and hackathon results.

Competitive Distinctions & Academic Rigor

competition

Winner — Smart India Hackathon (College Level)

Competed among 27 teams

competition

Selected — HCLTech Hackathon

Among 35 participating teams

coding

3★ Rating — CodeChef

coding

300+ Problems — LeetCode

coding

300+ Problems — GeeksforGeeks

academic

100/100 Mathematics — CBSE Class X

05 / TRAJECTORY & EDUCATION

Engineering Evolution

From mathematical problem-solving in Patna to building distributed infrastructure at IIIT Guwahati.

2019Foundation

Scored 92.4% in CBSE Class X with 100/100 in Mathematics. First encounter with programming logic.

2021PCM & Problem Solving

Completed Class XII with 89.2% in PCM. Started competitive programming and algorithmic thinking.

2022IIIT Guwahati

Began B.Tech at IIIT Guwahati. Deep dive into DSA, OOP, OS, and Computer Networks.

2023Full Stack & Hackathons

Won Smart India Hackathon (college level). Selected in HCLTech Hackathon. Built full-stack applications with React, Node.js, and PostgreSQL.

2024Systems Engineering

Shifted focus to distributed systems, concurrency, and Go. Built the Distributed Workflow Engine and SyncForge — production-grade infrastructure software.

2025AI + Systems

Combined systems engineering with AI — built CodeLens, a hybrid AST + LLM code review platform. 600+ DSA problems solved across platforms.

2026Now

Graduating from IIIT Guwahati. Exploring production engineering, observability, and scaling distributed systems in real-world environments.

Formal Academic Background

IIIT Guwahati2022 – 2026

B.Tech in Electronics & Communication Engineering

AN College, Patna2019 – 2021

Class XI & XII (PCM)

Score: 89.2%

Mother's International Academy2018 – 2019

Class X (CBSE)

Score: 92.4%

CURRENT RESEARCH & DEVELOPMENT

High-Throughput Distributed Engines

Currently diving deeper into consensus algorithms (Raft), eBPF-based network telemetry, and deterministic scheduling under extreme concurrency.