Senior Undergraduate, B.Tech AI — IIT Gandhinagar

Architecting production AI systems, modern full-stack web applications, and verified backend pipelines.

From responsive React & Next.js interfaces with MongoDB/PostgreSQL backends to multi-language AST transpilation and SLURM distributed pipelines. I build dependable systems that operate reliably at scale.

GitHubLinkedIn
< 12h turnaround response
Direct engineering consultation
Fixed-milestone & sprint contracts
┌───
───┐
└───
───┘
Portrait of Praveen Kumar - AI & Python Developer
Soket AI Labs
Available for freelanceWorldwide
Modern Full-Stack Apps · Next.js & ReactFrontend
Stanford & DeepLearning.AI Certified (Andrew Ng)Verified
University of London Full-Stack JS & MongoDB CertifiedAccredited
1.8M+ Files Processed in ProductionScale
53,000+ Verified AI Reasoning TracesLLMs
9 Languages AST TranspilationCompilers
36 Pods · 180 Concurrent Requests (SLURM & K8s)HPC
40+ Production REST Endpoints with FastAPIBackend
13,700+ Multimodal Datasets AnnotatedML
100% Deterministic Testing & CheckpointingReliability
IIT Gandhinagar · Artificial IntelligenceEducation
Open for Worldwide Contracts & Freelance RolesAvailable
Modern Full-Stack Apps · Next.js & ReactFrontend
Stanford & DeepLearning.AI Certified (Andrew Ng)Verified
University of London Full-Stack JS & MongoDB CertifiedAccredited
1.8M+ Files Processed in ProductionScale
53,000+ Verified AI Reasoning TracesLLMs
9 Languages AST TranspilationCompilers
36 Pods · 180 Concurrent Requests (SLURM & K8s)HPC
40+ Production REST Endpoints with FastAPIBackend
13,700+ Multimodal Datasets AnnotatedML
100% Deterministic Testing & CheckpointingReliability
IIT Gandhinagar · Artificial IntelligenceEducation
Open for Worldwide Contracts & Freelance RolesAvailable
Interactive Architecture Console

Test my system architecture live

Select an architecture below to see how I design, automate, and stress-test end-to-end AI pipelines for real client production.

Soket AI Labs Architecture·AST + Compiler-Validated AI Transpiler

Evaluated across 9 languages. Pairs AST semantic mapping with LLM synthesis and automated compiler-feedback retry loops (gcc, javac, tsc).

Real-Time Pipeline Execution Flow

01
Source AST
9 Languages
02
Two-Queue Scheduler
Threaded Pipeline
03
Hybrid LLM Synthesis
GPT-O3 / Qwen
04
Compiler Feedback
gcc / javac / tsc
05
Verified Target
Zero Semantic Gap
live-worker-stream.log
active
$ transpiler --source cpp --target rust --verify-compiler
[*] Parsing C++ AST: extracted 42 function symbols & memory layouts
[*] Dispatching to ThreadQueue: worker-04 assigned to batch #819
[*] LLM hybrid pass: generated target Rust source with borrow check hints
[*] Invoking rustc compiler validation harness...
✓ compiler exit code 0: 0 errors, 0 warnings (142ms)
✓ 100% deterministic type safety verified across AST diff
Target Languages
9 Pairs
C++, Rust, Java, TS, Go
Verification Pass
99.4%
Automated compiler harness
Parallel Throughput
180 Req
36 distributed pods
Avg Latency
142ms
FastAST pre-filter

Looking for a custom version of this pipeline?

I can build, test, and ship this directly to your cloud, Kubernetes cluster, or server.

Build this for my team

Selected work

A few projects worth a closer look

Each one started as an ambiguous problem. Here's what shipped, and what changed because of it.

1$ slurm-pipeline --dataset 10+ sources --scale Evol-Instruct ▍
2ingestion: 100K+ raw math problems (AIME, LIMO, DeepMath)
3mutation: 5-strategy instruction scaling with DeepSeek-V3.2
4teacher_eval: Kimi-K2.5 symbolic verification + rejection sampling
5✓ coverage: increased from 3.5% → 96.5%+ valid traces
6output: 53,000+ verified reasoning traces exported to Parquet
production-ready53K+ traces verified
AI / Data EngineeringFeatured

BigMath — Verified AI Training Data Pipeline

Designed and orchestrated an end-to-end pipeline processing 100K+ mathematical problems across 10+ datasets (DeepMath, LIMO, AIME, TheoremQA, etc.). Covers MCQ conversion, Evol-Instruct scaling with 5 mutation strategies, teacher reasoning generation, symbolic verification, and difficulty tagging — producing 53K+ verified reasoning traces.

Problem: High-quality, verified reasoning data for training math-capable LLMs is expensive to curate at scale.
Result: Fixed teacher-output parsing failures, improving verifiable coverage from 3.5% → 96.5%+. Ran 1000+ SLURM jobs with full failure-resume support.
PythonKimi-K2.5 / DeepSeek-V3.2 APIsHugging Face DatasetsParquetSLURM
1$ python train_multimodal.py --langs hi,te,ta,kn --gpu T4 ▍
2dataset: 13,700+ annotated memes with OCR text extraction
3backbone: IndicBERT + CLIP + VGG-19 + ConceptNet KG fusion
4parameters: 3.74M fusion head (frozen backbone weights)
5✓ evaluation: 3–4% Macro-F1 gain on code-mixed implicit harm
6serving: FastAPI real-time upload + inference endpoint
production-ready+3.4% Macro-F1
Full-Stack AI ApplicationFeatured

Multilingual Harmful Meme Detection & Web App

Curated and annotated 13,700+ multilingual memes, creating the first open-source benchmark datasets for Telugu and Kannada harmful meme detection. Implemented a MOMENTA-inspired multimodal pipeline integrating IndicBERT, CLIP, VGG-19, and ConceptNet, paired with a modern responsive web interface for live interactive inference.

Problem: No open benchmark or interactive classifier existed for harmful memes in most Indic languages.
Result: 3–4% Macro-F1 gains via ConceptNet enrichment on all four languages. Built an interactive full-stack web application (FastAPI + Modern Web UI) for live multi-image inference.
PyTorchIndicBERTCLIPFastAPIJavaScriptHTML5 / CSS3NLP
1$ python generate_report.py --input inspection_report.pdf ▍
2extractor: pdfplumber dual-stream text & thermal image parse
3llm_engine: Claude API with 7-section clinical diagnostic schema
4validation: strict Pydantic model with missing-data flagging
5✓ audit_log: 100% deterministic missing field alerts
6result: structured JSON report ready for engineer sign-off
production-readyAuditable JSON output
AI Document ProcessingFeatured

AI Diagnostic Report Generator

Built a document-intelligence system that extracts text and images from inspection and thermal PDFs, then uses the Claude API to assemble a seven-section diagnostic report in structured JSON — explicitly flagging missing or ambiguous data.

Problem: Engineers manually reviewing inspection PDFs spend hours extracting and formatting data prone to human error.
Result: Produces fully structured, auditable JSON reports with explicit missing-data flags — automating a previously manual extraction and summarization workflow.
PythonpdfplumberClaude APIJSON schemaPDF processing
1$ k8s-transpiler --cluster 36-pods --concurrent 180-req ▍
2architecture: two-queue threaded design with AST dependency analysis
3validation: real compiler feedback loop (gcc, javac, tsc)
4retry_policy: automated diagnostic error recovery per pod
5checkpointing: zero data loss across SLURM & Kubernetes evictions
6✓ scale: 1.8M+ files and 6.1B tokens across 72 language pairs
production-ready1.8M+ files processed
AI Systems EngineeringFeatured

LLM Code Transpilation Pipeline

Architected a repository-level transpilation pipeline using a two-queue threaded design integrating AST dependency analysis, real compiler validation (gcc, javac, tsc), and an automated compiler-feedback retry loop. Scaled to process 1.8M+ files and 6.1B tokens across 72 language pairs.

Problem: Deterministic AST transpilation fails at semantic gaps; LLMs alone hallucinate without compiler feedback.
Result: Hybrid LLM + compiler-feedback approach covering 9 languages (Python, C, C++, Java, JS, Ruby, PHP, TypeScript, C#) via 36 Kubernetes pods processing 180 concurrent requests.
PythonGPT-O3 / Qwen3-30BAST analysisKubernetesSLURMgcc / javac / tsc
1$ pytest tests/test_acid_transactions.py -v ▍
2storage_engine: custom B+ Tree in Python with O(log n) scans
3durability: Write-Ahead Logging (WAL) with fsync consistency
4concurrency: 2PL shared/exclusive locks + deadlock detection
5crash_recovery: ARIES analysis, REDO, and UNDO replay
6✓ test_suite: 50+ mid-transaction crash scenarios passed
production-ready50+ unit/crash tests
Systems & Backend

ACID-Compliant B+ Tree Database Engine

Designed a B+ Tree storage engine from scratch with O(log n) operations, full ACID transaction support via Write-Ahead Logging, shared/exclusive lock-based concurrency control, ARIES-inspired crash recovery, and a FastAPI layer exposing 40+ REST endpoints.

Problem: Understanding and implementing production-grade database internals requires building from first principles.
Result: Validated correctness through 50+ unit, integration, concurrency, and failure-recovery tests covering mid-transaction crashes and concurrent read-write race conditions.
PythonFastAPIMySQLWALB+ TreeREST APIspytest
1$ agent-stream --monitor social_channels --webhook-active ▍
2intent_parser: LLM classifier for commercial purchase signals
3pipeline: lead extraction, qualification, and schema validation
4crm_sync: automated dispatch to CRM endpoints via FastAPI
5✓ reliability: structured output guaranteed via JSON schema
6result: zero manual tracking required for inbound leads
production-readyEnd-to-end automation
AI Agents

AutoStream Social-to-Lead Agent

Built an AI-powered lead-generation agent that monitors social media signals, classifies purchase intent, and converts engagement into structured lead data for sales pipelines.

Problem: Manually tracking social media for purchase signals and converting them to CRM entries is time-consuming and error-prone.
Result: Automated end-to-end social signal detection, classification, and lead capture pipeline.
PythonLLM APIsFastAPIAutomation

Services & Capabilities

What I build for clients

Specialized engineering across modern full-stack web applications, applied AI systems, and high-performance backend infrastructure. Built for reliability, precision, and production scale.

Full-Stack Web Applications

I architect end-to-end full-stack web applications — from pixel-perfect, responsive UI design to database schemas and robust backend APIs. Focused on high-performance Core Web Vitals, seamless UX, and clean, type-safe architecture that scales effortlessly.

Mobile-first, high-performance responsive UI
Type-safe Next.js / React with clean state management
Scalable databases with MongoDB, PostgreSQL, or MySQL
Next.jsReactTypeScriptNode.jsTailwind CSSMongoDBREST APIs

AI Agents & LLM Applications

I design and build LLM-driven applications — from intelligent document processors to multi-step reasoning pipelines. Whether you need a RAG system, an AI agent, or a domain-specific chatbot, I architect it with reliable validation, structured outputs, and real compiler or rule-based verification.

Automate complex knowledge-work tasks
Structured JSON outputs from unstructured inputs
Compiler-backed or rule-based answer validation
OpenAI / Claude / Qwen APIsLangChainPrompt EngineeringPython

Backend APIs & Microservices

I build FastAPI and Node.js backends with 40+ endpoints, full test suites, and proper SQL/NoSQL integration. Whether you need a standalone microservice or a high-throughput data-ingestion API, I deliver well-documented, type-safe code your team can extend.

Fully documented OpenAPI specs
50+ automated tests per project
Clean architecture, easy to maintain
FastAPIPythonNode.jsPostgreSQL / MySQLMongoDBpytest

Machine Learning Solutions

From multimodal classification systems to fine-tuned transformer models, I build ML solutions grounded in proper experimental methodology — ablation studies, metric tracking, and clear evaluation on held-out data.

Measurable accuracy improvements
Ablation studies to validate design choices
Hugging Face ecosystem integration
PyTorchHugging FaceCLIP / IndicBERT / VGG-19Computer VisionNLP

Python Automation & Custom Scripts

Need a script that processes thousands of files reliably overnight? I build batch-processing systems with checkpointing, retries, and error recovery so your workflows don't silently fail. Tested with pytest, documented, and maintainable.

Save dozens of hours per week
Zero-loss processing with checkpointing
Reliable error handling and logging
PythonpytestPandas / NumPySLURM / HPCDocker

Intelligent Document Processing & RAG

I build document-intelligence systems that extract text and images from complex PDFs, apply LLM reasoning, and produce structured, auditable outputs. Built-in missing-data flagging means you always know what the AI found — and what it didn't.

Structured JSON from complex PDFs
Explicit flagging of missing / uncertain data
Significant reduction in manual review time
pdfplumberClaude APIPythonJSON schema validationRAG

Have a custom AI or Python requirement not listed here?

I frequently build bespoke pipelines, scraping engines, and customized APIs.

Discuss your project

Process & Reliability

How I work with freelance clients

A transparent, milestone-driven workflow designed to deliver production-ready software without surprises or delays.

01

Understand Your Requirements

Phase 01 of 05

I start by listening carefully. I ask detailed questions to understand the problem you're solving, the constraints you're working with, and what success looks like for your project.

Deliverable:System RFC & Technical Scope Doc
02

Plan the Technical Solution

Phase 02 of 05

Before writing a line of code, I map out the architecture, select appropriate tools, and share a clear plan. No surprises mid-project.

Deliverable:Data Flow Schema & Milestone Schedule
03

Build Iteratively

Phase 03 of 05

I develop in stages with regular updates. You see progress early and can give feedback throughout — not just at the end.

Deliverable:Tested Core Pipeline & Async Check-in
04

Test & Validate

Phase 04 of 05

Every deliverable is tested against real inputs. For AI systems, I validate on edge cases and document known limitations honestly.

Deliverable:Pytest Suite + Concurrency Load Report
05

Deliver & Document

Phase 05 of 05

Clean, commented code with a README and setup instructions. You'll know how to run, maintain, and extend what I build.

Deliverable:Containerized Build, Docs & 30-Day Support
Async & Direct Comm

Regular milestone summaries, Loom walkthroughs, and clear Slack / WhatsApp communication.

Full Test Coverage

Every deliverable includes automated pytest test suites and schema validation for edge cases.

Turnkey Handover

Complete setup guide, Dockerfiles, and environment configs so your team can deploy immediately.

Track Record & Education

Where I've engineered systems

Real production experience at high scale: multi-language compiler validation, 1.8M+ file batching, and formal AI education.

Technical Staff Intern

atSoket AI LabsDistributed Systems & LLM Engineering

High-throughput compiler validation and distributed LLM transpilation pipelines

Jul 2026 – Sep 2026
1.8M+ Files
6.1B tokens processed across 72 language pairs
36 Pods / 180 Workers
Sliding-window batch controller on SLURM & K8s
9 Languages AST
Compiler validation harness (gcc, javac, tsc)
  • ▹Evaluated deterministic transpilation across 9 programming languages, benchmarking AST mappers and identifying semantic-gap limitations that motivated a hybrid LLM approach (GPT-O3/Qwen3-30B).
  • ▹Architected a repository-level transpilation pipeline using a two-queue threaded design, integrating AST dependency analysis, real compiler validation (gcc, javac, tsc), and automated compiler-feedback retry loops.
  • ▹Scaled distributed execution across SLURM and Kubernetes for all 72 language pairs — engineered a sliding-window batch controller (36 pods, 180 concurrent requests) to process 1.8M+ files and 6.1B tokens.
  • ▹Diagnosed and resolved critical production bottlenecks including multi-threaded queue race conditions, Kubernetes naming collisions, and LLM request timeouts; implemented file-level checkpointing to ensure zero data loss on pod evictions.
PythonLLM APIsKubernetesSLURMAST AnalysisCompiler ValidationDockerPytest

B.Tech. in Artificial Intelligence

atIndian Institute of Technology, Gandhinagar

Comprehensive study of machine learning, system architectures, database engines, and high-performance algorithms

2023 – 2027

Core academic and laboratory coursework encompassing machine learning algorithms, database internals (B+ trees, WAL, ACID concurrency), computer vision, natural language processing, and scalable distributed computing.

Machine Learning AlgorithmsDatabase Internals & SystemsComputer VisionNatural Language ProcessingOperating SystemsMathematical Foundations of AIData Structures & Algorithms

Background & Philosophy

Engineering software that survives production

A background rooted in formal artificial intelligence, distributed systems scale, and relentless attention to edge cases.

I am an AI Systems & Full-Stack Web Developer and undergraduate at IIT Gandhinagar specializing in Artificial Intelligence. My work sits at the intersection where modern web interfaces, reactive frontend architectures, and high-reliability AI backends converge.

During my engineering work at Soket AI Labs, I designed compiler-feedback validation loops and scaled code-transpilation pipelines across Kubernetes and SLURM to process over 1.8 million files and 6.1 billion tokens without data loss.

Alongside distributed AI infrastructure, I build production-grade web applications — combining modern React, Next.js, and TypeScript frontends with MongoDB/PostgreSQL backends, REST APIs, and automated test harnesses. Whether building user-facing web tools, ACID-compliant database engines, or complex LLM pipelines, I engineer software built to withstand real production usage.

When collaborating with founders, engineering leads, and freelance clients worldwide, I prioritize clear asynchronous communication, rigorous test suites, and turnkey codebases that your internal team can deploy and maintain effortlessly.

Deterministic Guardrails First

I never rely on bare LLM prompts for mission-critical logic. Every output is strictly bounded by Pydantic schemas, AST diffing, or automated compiler feedback loops.

High-Throughput Concurrency Native

Having scaled jobs across 36 pods and 180 parallel workers, I engineer sliding-window batching, token-bucket rate limits, and atomic checkpointing into every pipeline.

Turnkey Handover & Pytest Suites

No messy scripts. Every client engagement includes Dockerized environments, 90%+ automated test suites, OpenAPI documentation, and a 30-day post-launch warranty.

Technical Stack & Tooling

Tools and disciplines I build with

Categorized by domain with zero arbitrary percentage bars — each technology backed by real production code, verifiable projects, and accredited coursework.

Full-Stack Web

ReactNext.jsTypeScriptJavaScript (ES6+)Node.jsHTML5 & Modern CSS3Tailwind CSSMongoDBResponsive DesignRESTful APIs
10 tools verifiedProduction ready

AI & Machine Learning

PyTorchSupervised LearningUnsupervised LearningReinforcement LearningLLM APIs (OpenAI / Claude / Qwen)Hugging FacePrompt EngineeringRAG & EmbeddingsMultimodal ML
9 tools verifiedProduction ready

Backend & Systems

FastAPIPythonNode.jsREST APIsPostgreSQLMySQLDatabase Internals (B+ Trees / WAL)pytestPydantic
9 tools verifiedProduction ready

NLP & Computer Vision

IndicBERTCLIPVGG-19OCR (Tesseract)ConceptNetTokenization & AST Analysis
6 tools verifiedProduction ready

Data & Distributed Systems

SLURM HPCKubernetesDockerPandas & NumPyParquet & JSONLBatch ETL PipelinesAtomic Checkpointing
7 tools verifiedProduction ready

Developer Tools & DevOps

Linux / ShellGit & GitHubTCP/IP & NetworkingCI/CD WorkflowsPostmanVS Code
6 tools verifiedProduction ready
Independently Verified Credentials

Certifications & Accreditations

Formal specializations covering Machine Learning algorithms, full-stack web application development, and distributed systems — each verified via Coursera with permanent certificate IDs.

Stanford Online · DeepLearning.AIJan 28, 2026
Verified

Supervised Machine Learning: Regression and Classification

Instructor:Andrew Ng (Adjunct Professor, Stanford)

Rigorous foundations of predictive modeling, vectorization, gradient descent mechanics, and multi-class classification from Stanford University and DeepLearning.AI.

Key Competencies

Supervised LearningLinear & Logistic RegressionGradient DescentOverfitting & RegularizationCost Function OptimizationNeural Network Foundations
Verify on Coursera
Stanford Online · DeepLearning.AIJan 28, 2026
Verified

Unsupervised Learning, Recommenders, Reinforcement Learning

Instructor:Andrew Ng (Adjunct Professor, Stanford)

Advanced ML systems covering anomaly detection, collaborative filtering recommenders, PCA, and deep reinforcement learning with continuous and discrete action spaces.

Key Competencies

Unsupervised LearningK-Means ClusteringAnomaly DetectionRecommender SystemsCollaborative FilteringDeep Q-Networks (RL)
Verify on Coursera
University of London · GoldsmithsFeb 4, 2026
Verified

Web Application Development with JavaScript and MongoDB

Instructor:Dr. Matthew Yee-King

Full-stack web application engineering covering dynamic client-server data flows, document-oriented NoSQL databases with MongoDB, reactive event-driven architecture, and secure session management.

Key Competencies

Full-Stack JavaScriptMongoDB NoSQLDynamic Web AppsRESTful CRUD APIsDocument Schema DesignSession & Auth Management
Verify on Coursera
University of London · GoldsmithsJan 8, 2026
Verified

Responsive Web Design & Modern Frontend Development

Instructor:Dr. Matthew Yee-King, Dr. Kate Devlin, Dr. Marco Gillies

Mastery of modern responsive layouts, fluid typography, mobile-first design patterns, CSS Grid and Flexbox systems, and cross-browser interactive interfaces built with clean JavaScript.

Key Competencies

Responsive Web DesignHTML5 & Modern CSS3CSS Grid & FlexboxMobile-First LayoutsDOM ManipulationCross-Device Compatibility
Verify on Coursera
University of ColoradoMar 7, 2026
Verified

Computer Communications Specialization (4 Courses)

Instructor:Prof. Xiaobo Zhou

Comprehensive 4-course specialization covering fundamental computer networking, protocol design principles, TCP/IP programming, packet switching algorithms, and network layer architectures.

Key Competencies

Network CommunicationsTCP/IP SuitePeer-to-Peer ProtocolsPacket Switching & RoutingNetwork Architecture & Sockets
Verify on Coursera
University of London · GoldsmithsJan 26, 2026
Verified

Introduction to Meteor.js Full-Stack Development

Instructor:Prof. Matthew Yee-King

Architecting real-time reactive web applications with full-stack JavaScript, covering data synchronisation, reactive templates, and cloud application deployment.

Key Competencies

Reactive FrontendFull-Stack JavaScriptReal-Time Data Publish/SubscribeMeteor.js FrameworkSingle-Page Applications
Verify on Coursera

Lifelong Engineering & Verification

All credentials above are cryptographically verifiable and backed by hands-on project deliverables.

View All on LinkedIn

Recognition

Selected achievements

2024

IIT Gandhinagar Explorer Fellowship

Competitive experiential learning programme for real-world AI research, selected competitively from across IIT Gandhinagar.

2023 – 2024

Dakshana Foundation Scholar

Selected through a rigorous national entrance exam, ranking in the top 1% of candidates nationwide.

2021 – 2022

Academic Honors & Distinctions

Consistently achieved top academic percentiles in national examinations (Class XII: 92.60%, Class X: 90.00% at J.N.V. Raichur).

Accepting Q4 2026 / 2027 Freelance Contracts

Have an AI project or technical challenge? Let's build it together.

Usually replies within 12 hours. Open to milestone-based freelance contracts, bespoke AI systems, and technical consultations worldwide.

Send a direct project inquiry
Fast 12-hour turnaround