AI Systems & Backend Engineer•NIT Kurukshetra•Available for Roles

I build AI systems that can be trusted in production.

I’m Rashmi Shaw, an AI systems and backend engineer building governed agents, real-time platforms, and event-driven services with Python, FastAPI, LangGraph, Kafka, Redis, and PostgreSQL.

Explore Systems GitHub Résumé

$ current_focus

>reliable agents

>real-time infrastructure

>open-source engineering

Kolkata, India · Open to remote work and relocation worldwide

Agent Trust Control Core9-Node LangGraph State Machine

PACKET_TRACE:Intent Classifier

LEDGER_HASH:0x9f8b...e4a1

3. AuthorizationRBAC & Ownership Guard

DETERMINISTIC

Verifies authenticated caller owns target resource. Blocks cross-tenant data leaks.

Enforced Policy:ResourceOwnershipRule + Multi-Tenant Boundary

500+

DSA problems solved

LeetCode algorithmic mastery across trees, graphs, dynamic programming, and concurrency

View LeetCode profile

5K+

Concurrent-user load test

Validated on StreamAlpha high-frequency event streaming with zero dropped packets under burst

Inspect load test ADR

65%

API latency reduction

Engineered via Redis caching, async connection pooling, and sub-millisecond leakage detection

View benchmark results

100%

Guarded task success

In 20-scenario synthetic evaluation testbed, eliminating unauthorized actions completely (5% to 0%)

Live verification console

Featured Case Studies

Production-Oriented Systems

Architectural decisions, reliability invariants, and empirical benchmarks from systems built to operate under real-world fault conditions.

01 // CASE STUDY•AI Safety · Agent Systems · Backend

Live Console API Swagger Source Full Spec

Execution Trace & Cryptographic Evidence Ledger

SHA-256 Chained

Simulate synthetic enterprise scenarios across the 9-node LangGraph state machine and inspect the immutable hash chain.

Zero Cross-Tenant Leaks

ACTIVE_TEST:01: Authorized Lookup

011. classify_intentPASSIntent identified as read:order_status

2.1ms

022. create_planPASSPlan generated: [lookup_order_status]

3.4ms

033. authorize_planPASSResourceOwnershipRule verified: tenant_id == caller_id

1.8ms

045. execute_toolPASSIdempotent query dispatched to OrderStore

8.2ms

056. validate_resultPASSPydantic schema validated (status: SHIPPED)

1.1ms

068. emit_evidencePASSChained to Block #1042 in immutable evidence ledger

2.9ms

Chained Cryptographic Blocks (O(N) Audit Ledger)Click any block to inspect payload or simulate tampering

BLOCK #1042 EVIDENCE PAYLOADSigner: HMAC_SHA256_KMS

Previous Block Hash:0000a4f2...7891

Current SHA-256 Hash:e3b0c442...b855

Payload JSON:

{
  "order_id": "ORD-8841",
  "tenant_match": true,
  "privilege": "READ_ONLY"
}

Enterprise Agent Trust Platform

Lead Systems Architect & Backend Engineer

A governance and execution layer that allows AI agents to perform real actions through deterministic permissions, policy validation, human approvals, and auditable execution.

Problem Space

When autonomous LLM agents are given tool-calling access to mission-critical commerce operations (order cancellations, refunds, address edits, catalog mutations), probabilistic reasoning causes catastrophic failures: cross-tenant access violations, uncontrolled financial payouts, cascading retry storms during network 429/500 errors, and untraceable black-box logs.

Key Architectural Decisions

Explicit 9-Node State Machine over Open Loop ReAct

Separates intent classification, planning, authorization, tool dispatch, validation, recovery, and auditing into deterministic states. Prevents infinite tool loops and enforces hard stop invariants.

Tradeoff: Adds 22.5 ms latency overhead compared to an unchecked open-loop call, but guarantees zero unauthorized actions.

SHA-256 Append-Only Hash-Chain Evidence Ledger

Every mutation is linked to the previous block hash with payload signing. Provides O(N) mathematical verification to pinpoint exact corrupted records if database rows are modified.

Tradeoff: Storage overhead per transaction increases by ~1.2 KB to record payload hashes and cryptographic signatures.

Measured Production Outcomes

Metric	Result	Delta
Guarded Task Success Rate	100.0%	+40.0%
Unauthorized Action Rate	0.0%	-5.0%
Fault Recovery Rate	66.7%	+33.4%
Escalation Precision	100.0%	+75.0%
Audit Completeness	100.0%	+100.0%

Technology Stack

Python 3.11+FastAPILangGraphPostgreSQLRedisAsync SQLAlchemyDockerPydantic v2

02 // CASE STUDY•Real-Time Systems · Distributed Backend

Source Full Spec

Real-Time Event Stream & Backpressure Pipeline

Producer → Kafka/Redpanda → Stream Processor → Redis/PostgreSQL → WebSocket Clients

01. INGESTION

Tick Producer

Financial market feeds (AAPL, NVDA, MSFT) publishing live tick events.

ACTIVE_STREAM

02. BROKER

Kafka / Redpanda

Partitioned topic logs guaranteeing per-symbol total order under load.

LAG: 0 TICKS

03. ROUTER

FastAPI Gateway

Asynchronous ring buffer manager dispatching frames & handling backpressure.

p50: 2.57 ms

04. STORAGE

Redis + Postgres

Redis for sub-1ms state snapshot cache; PostgreSQL for 1s/1m OHLCV batch aggregations.

BATCH COPY: 1s

05. CLIENTS

WASM Clients

Perspective WebAssembly rendering in Web Worker at 60 FPS without freezing UI.

BUFFER CAPACITY: 98%

LIVE STREAM TELEMETRY

THROUGHPUT10,000 evt/s

TOTAL TICKS STREAMED1,420,500

SLOW CLIENT EVICTIONS0 (Healthy)

BROWSER RENDER FPS60.0 FPS

StreamAlpha

Distributed Systems & Streaming Architect

A real-time distributed market analytics platform built around event streaming, low-latency state, and WebSocket delivery capable of 10,000 events/second.

Problem Space

High-frequency financial market updates overwhelm typical web architectures: WebSocket broadcast storms freeze browser client renderers, slow consumers cause catastrophic memory leaks in the backend, and database write throughput collapses when persisting sub-second tick streams.

Key Architectural Decisions

Per-Client Bounded Asynchronous Ring Queues

Each WebSocket client connection receives an isolated bounded queue. If a client stalls, oldest non-critical ticks are evicted without blocking the shared event ingestion pipeline.

Tradeoff: Stalled clients may drop intermediate ticks, but server memory usage remains strictly O(1) bounded and other clients experience zero lag.

FINOS Perspective WebAssembly Engine in Web Worker

Processed 10,000 updates/second entirely in a Web Worker running C++ compiled to WebAssembly. Only viewport diffs are sent to the DOM, keeping main thread UI rendering rock solid at 60 FPS.

Tradeoff: Increased initial bundle payload by ~420 KB for WebAssembly binaries.

Measured Production Outcomes

Metric	Result	Delta
100 evt/s Throughput	p50: 2.70 ms \| p95: 7.10 ms	0 dropped events
1,000 evt/s Throughput	p50: 2.57 ms \| p95: 6.87 ms	0 dropped events
5,000 evt/s Throughput	p50: 5.83 ms \| p95: 10.79 ms	0 dropped events
10,000 evt/s Burst Load	p50: 12.56 ms \| p95: 17.09 ms	0 dropped events

Technology Stack

Python 3.12FastAPIApache Kafka / RedpandaRedis 7PostgreSQL 16WebSocketsDockerPrometheusGrafanaFINOS Perspective WebAssembly

03 // CASE STUDY•Applied AI · Experimentation · Business Automation

Source Full Spec

Architecture TopologyVERIFIED IN PROD

Processes incoming billing and checkout webhooks through a sub-millisecond regex/domain rule filter. Computes an Expected Recovery Value (ERV = Revenue at Risk * Recovery Probability - Intervention Cost). Splits opportunities 50/50 via deterministic salt-hashing into Control (Holdout) and Treatment. The LangGraph agent designs tailored intervention strategies bounded by hard policy invariants, routing concessions exceeding $500 to a human approval queue.

Security & Reliability Guardrails

Built-in RBAC: ADMIN (full authorization & policy mutation), OPERATOR (queue monitoring & standard actions), VIEWER (read-only audit).
Margin Guard: Total concessions cannot exceed 20% of customer historical LTV.
Human-in-the-Loop Review Queue: Concessions > $500 or refund disputes pause for administrative sign-off.

RevenueGuard

AI & Platform Engineer

An event-driven revenue recovery system that detects revenue leakage, calculates Expected Recovery Value (ERV), and safely executes interventions within strict policy invariants.

Problem Space

E-commerce platforms lose significant annual revenue to payment gateway failures, abandoned checkouts, and churn cancellations. Naive automated recovery scripts bombard customers with expensive discount spam, erode gross margins, and misattribute organic renewals as recovery wins.

Key Architectural Decisions

Deterministic Pre-Filter before LLM Invocation

Filters non-recoverable events (< 1ms) using domain rules without burning expensive LLM tokens on unrecoverable transactions.

Tradeoff: Requires maintaining explicit pattern rules for gateway error codes.

Salt-Hashed Randomized Holdout Experimentation

Consistently hashes opportunity IDs to 50% holdout control groups to measure true counterfactual incremental revenue lift.

Tradeoff: 50% of recoverable opportunities are intentionally withheld from intervention to maintain scientific statistical rigor.

Measured Production Outcomes

Metric	Result	Delta
Leakage Triage Latency	< 1 ms (Engine)	99.3% reduction
Causal Recovery Lift	+24.8% Incremental	Statistically verified
Policy Compliance Rate	100.0% (Deterministic)	+12.0%

Technology Stack

Python 3.11+FastAPILangGraphSQLAlchemyNext.jsPydantic v2PostgreSQLRedis

04 // CASE STUDY•Multi-Agent RAG · Enterprise Search

Source Full Spec

Architecture TopologyVERIFIED IN PROD

Employs a multi-agent orchestration workflow in LangGraph. A Query Planning Agent decomposes complex questions into targeted sub-queries. A Hybrid Retrieval Engine searches Qdrant for semantic embeddings and Elasticsearch for exact keyword matches, fusing rankings via Reciprocal Rank Fusion (RRF). A Verification Agent audits retrieved chunks to filter hallucinations before the Synthesizer outputs answers linked to verifiable source citations.

Security & Reliability Guardrails

Strict Document Citations: Every paragraph links directly to clickable source references with chunk highlight coordinates.
Granular Permission Masking: Respects document ACLs so unauthorized users cannot retrieve confidential HR or executive files.
Redis Token & Session Cache: Fast caching for active user dialogues and vector lookup speedups.

NexusAgent

Lead AI Engineer

An enterprise knowledge platform that connects organizational data sources and generates verified, source-grounded answers with interactive citations.

Problem Space

Enterprise knowledge is fragmented across GitHub repositories, Jira tickets, Slack channels, Confluence spaces, and internal PDFs. Generic single-shot RAG pipelines retrieve irrelevant context, hallucinate false answers, and fail on domain-specific keyword searches.

Key Architectural Decisions

Reciprocal Rank Fusion (RRF) Hybrid Search

Combines dense semantic vector retrieval (Qdrant) with sparse BM25 keyword search (Elasticsearch). Solves vector blindspots for precise acronyms, commit hashes, and error codes.

Tradeoff: Requires maintaining two search indices and running dual queries in parallel.

Dedicated Factuality Verification Agent

Cross-references draft claims against source chunk text prior to streaming the final response, stripping unsupported assertions.

Tradeoff: Adds ~1.4 seconds to time-to-first-token, but reduces factual hallucination rates to near-zero.

Measured Production Outcomes

Metric	Result	Delta
Retrieval Precision @ 5	91.8% (Hybrid RRF)	+27.6%
Hallucination Rate	< 1.0% (Verified)	-13.5%
Query Synthesis Latency	p50: 1.8s \| p95: 2.6s	Streamed tokens

Technology Stack

Python 3.11+FastAPILangGraphNext.js 15PostgreSQLQdrantElasticsearchRedisDocker

Full Repository Catalog

Explore All Other Projects on GitHub

Beyond these 4 production case studies, all additional experimental prototypes, algorithm benchmarks, utility libraries, and engineering repositories are maintained publicly on GitHub.

View All on GitHub (@musi22)

Interactive Systems Architecture

Engineering Capabilities

Represented as an interconnected system architecture—not arbitrary percentage bars. Each tier reflects production implementation experience with verifiable failure handling.

Agent & AI Systems

SYSTEM LAYER SPECIFICATION

Deterministic orchestration architectures that turn non-deterministic models into production-grade systems with verifiable guarantees.

Production Implementation Context

Built 9-node state machines in LangGraph separating classification, planning, authorization, tool calling, human-in-the-loop sign-off, validation, and SHA-256 evidence logging.

Core Technologies & Invariants

LangGraphProduction

Cyclic state graphs, checkpointing, conditional branches

LangChainProduction

Prompt pipelines, schema parsers, tool abstractions

Agent OrchestrationCore

Multi-agent planner-verifier-synthesizer topologies

LLM Tool CallingProduction

Strict Pydantic v2 JSON-schema deterministic dispatch

RAG & Hybrid SearchAdvanced

Dense semantic + sparse BM25 with Reciprocal Rank Fusion

Human-in-the-LoopProduction

Supervisory queues for high-risk concessions > $50

Policy EnforcementProduction

Deterministic RBAC, resource ownership, prompt injection defense

Background & Principles

Engineering AI Systems That Survive the Demo

I’m a recent B.Tech Information Technology graduate from NIT Kurukshetra who enjoys building systems where AI meets serious backend engineering. My work focuses on agent reliability, distributed services, retrieval systems, authorization, observability and production failure handling.

I’m especially interested in AI systems engineering, backend/platform engineering, applied AI and open-source infrastructure.

DETERMINISTIC BOUNDARIES

Probabilistic models are brilliant at synthesis and reasoning, but must never be allowed unvalidated write access to production databases.

BACKPRESSURE & FAULT TOLERANCE

High-frequency streams must withstand downstream lag gracefully through bounded ring buffers and proactive backoff rather than silent memory death.

Rashmi Shaw

NIT Kurukshetra · AI Systems & Backend

Education & Credentials

2022–2026

National Institute of Technology, Kurukshetra

B.Tech in Information TechnologyCGPA: 8.0 / 10.0

Core courses: Distributed Systems, Operating Systems, Database Management Systems, Computer Networks, Data Structures & Algorithms

500+ DSA algorithmic problems solved on LeetCode with strong focus on graph theory, dynamic programming, and concurrency

Leadership & Community Impact

Core Member

Shiksha NGO

Supported educational initiatives reaching 180+ underprivileged students and helped coordinate 150+ volunteers across educational workshops, logistics, and resource mobilization.

180+Students Reached

150+Volunteers Coordinated

Contact & Direct Inquiries

Let’s build a system that survives the demo.

I’m open to AI systems, backend, applied AI and software engineering opportunities, as well as selected freelance automation projects.

DIRECT EMAILshawrashmi7@gmail.com

Send Mail

LinkedIn GitHub Résumé

+91-9051307659

WhatsApp Call Directly

Direct Dispatch Channel

SPAM PROTECTED