RS
RISHI SINGH
Software Engineer · AI / ML · Data Systems

I build systems
that make complex
things feel simple.

Full-stack products, applied AI workflows, and reliable data systems — designed with intent, validated with deterministic code, and built to ship.

Education: Bennett University 2027
Verified: 45+ Vitest Specs
System Telemetry : Data-to-Insight Engine
Stage [VALIDATE] : Deterministic ValidatorDeterministic TS · Zero Hallucination

Physiological plausibility limits (PLAUSIBILITY_BOUNDS), duplicate detection, and missing unit audits.

Active In VitalTrace & DocMind
Deterministic Rule Enforcement: 0 Unverified ObservationsLatencies: p50 < 420ms
FOCUS
Product Engineering / Applied AI / Data Quality
BUILDING
VitalTrace
EDUCATION
B.Tech CS (AI/ML) · 2027
Bennett University · CGPA 7.55
BASED IN
Greater Noida, India
Engineered Systems

SELECTED SYSTEMS

Production-focused applications and systems built around real engineering constraints and verified codebases.

View All Projects
HEALTHCARE · AI · DATA QUALITYCompleted & Tested45 Vitest Specs Passing

VitalTrace

Personal Health Record Intelligence & Deterministic Data Quality

Full-stack clinical data intelligence system that ingests unstructured lab reports, executes deterministic physiological validation, normalizes test aliases to LOINC standards, and tracks longitudinal biomarkers with zero hallucination tolerance.

Core Implementation Attributes
  • Deterministic biological plausibility limits check (PLAUSIBILITY_BOUNDS)
  • PostgreSQL 15+ caller-based RLS via WITH (security_invoker = true)
  • Zero-hallucination LOINC dictionary: unmapped tests retain raw names with null codes
React 19TypeScriptSupabasePostgreSQL RLSGemini APIZodVitest
VitalTrace · Ingestion & Validation Workbench
RUN_ID #7b9a4c
Complete Blood Count (CBC) Panel
Extracted via Gemini 1.5 Edge · 8 Observables
Schema Validated
Hemoglobin (Hb)
LOINC 718-7 · Canonical
14.2 g/dL
Ref: 12.0 - 16.0 [NORMAL]
Fasting Blood Sugar (FBS)
LOINC 1558-6 · Alias Normalized
142 mg/dL
Ref: 70 - 99 [ELEVATED]
Specialized IgG Panel
LOINC: NULL (Raw Name Preserved)
11.8 mg/L
Zero Hallucination Gate
Edge Latency
382 ms
Pass Rate
100% Deterministic
Review Gate
Human Sign-off
DOCUMENT AI · HYBRID SEARCH · RAGCompleted & TestedDense + Sparse RRF Engine

DocMind AI

Hybrid RAG Document Intelligence Platform with Page-Level Lineage

Enterprise document question-answering and synthesis engine combining FAISS dense vector search with BM25 sparse keyword matching via Reciprocal Rank Fusion, exact page citation pills, and dual Groq/Ollama inference backends.

Index Mode:FAISS IndexFlatIP + BM25Okapi
Fusion Strategy:Reciprocal Rank Fusion (RRF, k=60)
Dual Inference:Groq Llama-3.1 & Ollama Mistral
Page Lineage:Exact [Source: Page X] binding
PythonFastAPIFAISSBM25LangChain
CLIMATE TECH · CONSTRAINT SCHEDULINGIn Development48/48 Pytest Passing

WorkWise

Climate-Aware Construction Task Scheduling Engine

Predictive thermal strain and occupational safety platform for Indian construction operations, replacing crude clock rules with Liljegren (2008) physical WBGT modeling, CAQM GRAP regulatory constraint scheduling, and Bedrock AI briefings.

Thermal Formulation:Liljegren (2008) Physical WBGT
Architecture Rule:Deterministic Safety Decides; AI Explains
Regulatory Engine:CAQM GRAP Stage III/IV Dust Ban
Automated Tests:48/48 Pytest Passing (100%)
Python 3.13React 19AWS SAMLiljegren WBGTAmazon Bedrock
Technical Tooling

ENGINEERING SKILLS & STACK

Technologies, architectures, and systems verified through shipped codebases and automated test suites.

Languages

7 tools

Core languages used for systems, backend services, and algorithmic problem-solving

C++Primary
DSA, LeetCode 200+, high-performance logic
PythonPrimary
FastAPI, PyTorch, FAISS, Pandas, AI pipelines
TypeScriptPrimary
Strict mode, Next.js, React 19, Supabase Edge
JavaScriptPrimary
ES6+, Node.js, full-stack web applications
SQLPrimary
PostgreSQL 3NF schemas, analytical views, RLS policies
C
Systems fundamentals, memory management, low-level data structures
HTML5 & CSS3
Semantic web standards, responsive layout architecture

Frontend Engineering

5 tools

Modern component architectures, state orchestration, and accessible interfaces

React 19 / React.jsPrimary
Server & client components, hooks, custom state
Next.jsPrimary
App Router, server-rendered views, SEO, static generation
Tailwind CSSPrimary
Design token systems, custom responsive typography
Vite
Modern ESM build pipelines and test environments
Streamlit
Rapid analytical dashboards & ML prototype interfaces

Backend & Systems

5 tools

Asynchronous worker queues, REST API design, and distributed architectures

FastAPIPrimary
Asynchronous Python services, Pydantic validation, OpenAPI
Node.js & Express.jsPrimary
Event-driven runtime, RESTful middleware pipelines
RabbitMQPrimary
Message queues, worker pools, 42-agent news pipelines
REST API Design
Idempotent endpoints, status contracts, pagination
Distributed Systems
Worker concurrency, circuit breaking, decoupling

Databases & Storage

6 tools

Relational modeling, vector search indices, and multi-tenant security

PostgreSQLPrimary
3NF schemas, foreign keys, triggers, CTE analytics
Supabase & RLSPrimary
Row-Level Security, security_invoker views, auth.uid()
FAISS & QdrantPrimary
High-dimensional vector indexing, FlatIP similarity
Redis
In-memory caching, queue management, session state
MongoDB & MySQL
Document collections and transactional persistence
Elasticsearch
Full-text indexing, BM25 scoring, inverted indices

AI / Machine Learning

5 tools

Applied NLP, hybrid retrieval pipelines, and sequence modeling

Hybrid RAG (Dense+Sparse)Primary
FAISS + BM25 with Reciprocal Rank Fusion
PyTorch & TensorFlowPrimary
Seq2Seq LSTMs, attention mechanisms, transfer learning
LangChain
Strategy patterns, context orchestration, prompt templates
Scikit-learn
Feature engineering, classification, evaluation metrics
Groq & Ollama
High-throughput cloud inference & local offline LLMs

Data Quality & Validation

4 tools

Zero-hallucination guardrails, clinical coding standards, and deterministic checks

Deterministic ValidationPrimary
Biological plausibility limits, unit standardization
Zod & PydanticPrimary
Runtime schema validation and type narrowing
LOINC Code MappingPrimary
Clinical alias dictionary, exact matching, null fallback
Pandas & NumPyPrimary
Telemetry percentiles (p50/p95), statistical transforms

DevOps & Testing

5 tools

Containerization, automated test suites, and proactive observability

Docker & Docker ComposePrimary
Multi-service container stacks, isolated networks
Kubernetes
Manifests, rolling updates, liveness & readiness probes
Vitest & PytestPrimary
Unit tests, integration suites (45 Vitest, 48 Pytest)
Prometheus & Grafana
Metrics scraping, time-series dashboards, alerting
Git / GitHub
Branching strategies, CI workflows, release tags
Academic & Professional Track

EXPERIENCE & EDUCATION

Verified academic milestones, commercial engineering experience, and competitive algorithmic metrics.

Commercial Software Engineering

Web Developer @ Satvicpath

Dec 2025 – Mar 2026
Remote / India
  • Collaborated with stakeholders to gather user requirements and applied sound engineering principles to design and ship responsive, production web applications (React.js, Node.js, HTML/CSS/JS) from feature spec to deployment.
  • Built and integrated RESTful APIs to fetch, process, and render real-time data from backend services and databases, improving page load performance and interactivity for end users.
  • Integrated Razorpay payment gateway end-to-end, managing secure transaction data flow through backend REST APIs in a cooperative, cross-functional team environment.
React.jsNode.jsREST APIsJavaScriptHTML/CSSRazorpay
Formal Education

Bennett University

CGPA: 7.55 / 10
B.Tech in Computer Science (Artificial Intelligence & Machine Learning Specialization)
Aug 2023 – June 2027 · Greater Noida, India
  • ▸Rigorous coursework in Data Structures & Algorithms, Object-Oriented Programming, Operating Systems, Computer Networks, and Machine Learning.
  • ▸Practical engineering across full-stack applications, distributed async pipelines, and applied AI systems.
  • ▸Expected Graduation: June 2027.

Air Force School

75.1%
Class 12 (Senior Secondary Education)
Apr 2022 – Mar 2023 · India
  • ▸Science & Mathematics curriculum.

Dr. Virendra Swarup Education Center

80.4%
Class 10 (Secondary Education)
Apr 2020 – Mar 2021 · India
  • ▸Foundational STEM and computer science coursework.
Verified Certifications
Neural Networks and Deep Learning
DeepLearning.AI
Data Structures
University of California San Diego (UC San Diego)
Dynamic Programming & Greedy Algorithms
University of Colorado Boulder (CU Boulder)
Next-Gen Workplace Automation with GenAI Specialization
Coursera / Industry Specialization
Interactive Deep Dive

FROM INPUT TO INSIGHT

Inspect the 6-stage clinical data quality architecture engineered in VitalTrace.

Full VitalTrace Case Study
Stage 03 SpecificationClinical Rule Validator Engine

Deterministic Validator

Executes deterministic biological bounds checks, duplicate specimen collision audits, and missing unit verification. Flags extreme physiological values requiring clinical attention.

src/lib/validationRules.ts
Architectural Guarantee

Zero unverified AI records: Extreme values cannot bypass human review gate.

Verified Metric:Rule Evaluation: < 2ms · 45 Vitest test specifications verified
Production Implementation SnippetTypeScript / SQL
// Biological plausibility limits check
export function validateObservation(obs: RawObservation): ValidationResult {
  const bounds = PLAUSIBILITY_BOUNDS[obs.loinc_code];
  if (bounds && obs.value_numeric !== null) {
    if (obs.value_numeric < bounds.min || obs.value_numeric > bounds.max) {
      return {
        severity: "CRITICAL_PLAUSIBILITY_BREACH",
        message: `Value ${obs.value_numeric} outside physiological limits (${bounds.min}-${bounds.max})`
      };
    }
  }
  return { severity: "PASS", message: "Valid" };
}
Engineered for VitalTraceReview full system architecture
Core Engineering Philosophy

HOW I ENGINEER

Four foundational engineering principles applied across full-stack applications, applied AI pipelines, and data systems.

01

Design the system

Break complex problems into distinct decoupled components, formal schemas, explicit interfaces, and predictable data contracts.

Verified Repository Evidence
In Dhara News, decomposed real-time news verification into a 42-agent asynchronous RabbitMQ queue architecture, preventing crawl bottlenecks from blocking downstream analysis.
02

Make data trustworthy

Never allow probabilistic models to become final arbiters. Enforce strict deterministic boundary checks, clinical plausibility limits, and canonical standardization.

Verified Repository Evidence
In VitalTrace, engineered a deterministic validation engine enforcing physiological plausibility bounds and zero-hallucination LOINC dictionary mapping (null fallback on unrecognized tests).
03

Build for reliability

Validate systems with automated test suites, multi-tenant database isolation, explicit error handling, and zero-leakage security boundaries.

Verified Repository Evidence
Enforced PostgreSQL 15+ caller-based RLS via WITH (security_invoker = true) in VitalTrace, and verified 48/48 automated pytest unit tests in WorkWise.
04

Make the result useful

Build interfaces that expose the exact necessary telemetry, preserve source citations, and make the next operational decision immediate.

Verified Repository Evidence
In DocMind AI, constructed a word-to-page citation pipeline rendering interactive citation pills that trace generated text back to the exact physical PDF page.
Open for Software Engineering Roles

Have an interesting engineering problem?

I enjoy building useful software, working through complex systems, and turning technical ideas into reliable, well-tested products. Let's connect.