Yuvraj Singh Bhadoria
LLM Developer
Python
Node JS
C++
Experimentation & Evaluation: 6/10
MLOps & Deployment: 6/10
Computational Efficiency: 5/10
Active 27 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
LLM infrastructure engineer at a senior level specializing in production LLM serving and MLOps. The strongest proven skill is building production-ready LLM inference and platform integration, evidenced by the scaling/router logic and extensive enterprise tests (e.g. backend/gateway/scaling/router.py and backend/tests/test_enterprise_apis.py). There is little to no evidence of custom model training, novel architectures, or low-level GPU kernel development in the public code.
Phone
Technical skills
Languages
3
Python
Node JS
C++
Python
8
FastAPI
SQLAlchemy
Pydantic
Asyncio
HTTPX
Alembic
Marshmallow
Uvicorn
Databases
3
PostgreSQL
Redis
MongoDB
AI/ML
13
LLM
LoRA
PyTorch
TensorRT-LLM
AWQ
PEFT
CUDA Toolkit
SGLang
Triton
CUDA
vLLM
TPOT
LLMOps
DevOps
9
Kubernetes
Prometheus
Docker Compose
GitHub
Grafana
Docker
Git
Linux
Rest API
Other
8
Bcrypt
PyTorch C++
TensorRT
Quantization
Cortex
KEDA
Speculative Decoding
KV Cache
Timeline
ML Engineer, LLM Inference
•
Middle
kipi.ai
•
Full-Time
Optimized LLM inference for enterprise GenAI on Snowflake Cortex by tuning serving configuration and prompts, reducing latency and increasing concurrency while maintaining frozen quality. Built production LLM review pipelines on Cortex Complete using scoring logic aligned to project plans and account history. Improved cost efficiency by deduplicating extracted files, budgeting prompt tokens, and isolating failures per use case, with end-to-end unit tests.
ML Engineer
•
Middle
Bank of America
•
Full-Time
Optimized GPU kernels for LLM serving (vLLM) for an enterprise assistant, reducing both latency and API cost while keeping frozen quality. Used a profile-measure-iterate workflow to improve GPU memory throughput and L2 cache hit rate, and tuned KV-cache behavior for serving performance. Implemented quantization and model selection across vLLM, SGLang, and TensorRT-LLM, and built tooling to benchmark latency/throughput using Nsight Systems and Nsight Compute.
vLLM
TensorRT-LLM
Quantization
KV Cache
CUDA
Senior Data Scientist (Contract)
•
Senior
Policybazaar
•
Contractor
Applied LLM inference optimization and RLHF-based post-training to production document workflows. Used C++17 for performance-critical tuning and supported integration of optimized inference into operational pipelines.
C++
Data Scientist
•
Middle
Infosys
•
Full-Time
Built production machine-learning solutions end-to-end for enterprise clients, covering experimentation through deployment. Conducted systematic benchmarking and performed quality validation to ensure reliable model performance in production settings.
Rustamji Institute of Technology
Bachelor's Degree •
Computer Science and Engineering
Senior AI/ML Engineer
Confidence: High LLM Engineer
LLM infrastructure engineer at a senior level specializing in production LLM serving and MLOps. The strongest proven skill is building production-ready LLM inference and platform integration, evidenced by the scaling/router logic and extensive enterprise tests (e.g. backend/gateway/scaling/router.py and backend/tests/test_enterprise_apis.py). There is little to no evidence of custom model training, novel architectures, or low-level GPU kernel development in the public code.
Model Architecture & Training
1/10
How well models are designed and trained
Minimal evidence of model architecture design or custom training; repository contains an inference wrapper and engine integration but no custom model implementations or training loops.
Evidence
backend/inference/engine/vllm_engine.py
backend/tests/test_engine.py
Data Pipeline & Feature Engineering
1/10
How data is prepared for models
Basic data and schema design for application/tenant data is present (SQLAlchemy models and design docs) but no ML data pipelines, augmentation, or feature engineering artifacts are shown.
Evidence
docs/05_Database_Design.md
backend/database/models.py
Experimentation & Evaluation
6/10
How results are measured and tested
Strong, reproducible evaluation and measurement practices for inference performance and experiments are present in the CPU inference study and the codebase includes a broad, well-covered test suite for the platform.
Evidence
llm-cpu-inference-optimization/README.md
llm-cpu-inference-optimization/speculative-decoding/code/speculative_server.py
backend/tests/test_enterprise_apis.py
MLOps & Deployment
6/10
How models are shipped to production
Clear engineering of MLOps and deployment concerns: async FastAPI services, scaling/router/circuit-breaker/replica manager, k8s manifests and Helm design, observability and many integration tests.
Evidence
backend/gateway/scaling/router.py
docs/09_Scaling_Reliability_Design.md
backend/tests/test_kubernetes.py
Computational Efficiency
5/10
How efficiently computing resources are used
Measured computational-efficiency work is evidenced in the CPU inference optimization study (threading, quantization, benchmarking), though there are no low-level CUDA/Triton kernels in these files.
Evidence
llm-cpu-inference-optimization/scripts/balancer.py
llm-cpu-inference-optimization/speculative-decoding/code/speculative_server.py
Research Depth & Innovation
4/10
Depth of research and new ideas
Good experimental rigor and domain knowledge shown in the CPU inference case study and careful measurement, but no reproduced SOTA model implementations or novel deep-learning algorithms.
Evidence
llm-cpu-inference-optimization/README.md
llm-cpu-inference-optimization/bandwidth-characterization/README.md
Verified artifacts
Expertise
LLM• Senior
MLOps & Model Lifecycle• Senior
Industries
Artificial Intelligence• Senior
Technologies
C++• since 2025
MongoDB
Docker Compose
LoRA
vLLM• since 2025
CUDA Toolkit
KEDA
Prometheus
Quantization• since 2025
SGLang
AWQ
TensorRT
PEFT
TensorRT-LLM• since 2025
Git
PyTorch
Docker
Kubernetes
Grafana
PyTorch C++
Marshmallow
Cortex
TPOT
CUDA• since 2025
Triton
GitHub
Speculative Decoding
KV Cache• since 2025
Linux
Docker• mentioned only
Llama• mentioned only
llama.cpp• mentioned only
LLM• mentioned only
MLOps• mentioned only
Quantization• mentioned only
vLLM• mentioned only
Recommendations
- Develop production LLM serving systems and MLOps features (scaling, routing, circuit-breakers, observability and tenant isolation).
- Lead inference performance and efficiency projects (CPU inference benchmarking, quantization, batching and thread-topology optimization).
- Implement secure enterprise features for LLM platforms (RBAC, API-key scoping, audit hash chaining, quotas and rate limiting).
- Build observability and reliability tooling (Prometheus metrics, health/readiness semantics, K8s manifests, and CI for infra).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Data Scientist
Confidence: High Data Engineer
A senior-level data engineer specializing in production-grade LLM serving and inference infrastructure with strong systems design and test discipline.
Statistical Rigor
4/10
Correct use of statistics
Measurement-focused experimental rigor is present in the CPU inference study (repeated runs, median reporting and explicit variance checks), but there is limited formal statistical testing, uncertainty quantification, or causal analysis in the codebase.
Evidence
llm-cpu-inference-optimization/speculative-decoding/README.md
llm-cpu-inference-optimization/bandwidth-characterization/README.md
llm-cpu-inference-optimization/bandwidth-characterization/code/analyze.py
Data Wrangling & Cleaning
4/10
Preparing and cleaning data
Practical data collection and result parsing pipelines exist for benchmarking and reproducible experiments, but there is little evidence of large-scale ETL, provenance tooling (DVC), or advanced cleaning suites.
Evidence
llm-cpu-inference-optimization/bandwidth-characterization/code/analyze.py
llm-cpu-inference-optimization/results/*.json
Exploratory Analysis & Visualization
4/10
Exploring and visualizing data
Exploratory analysis and clear presentation of experimental results are present in experiment READMEs and plotting scripts; narrative interpretation is visible in the study documentation.
Evidence
llm-cpu-inference-optimization/speculative-decoding/README.md
llm-cpu-inference-optimization/scripts/plot_balancer.py
Predictive Modeling
1/10
Building models that predict
No predictive modeling or ML training pipelines are present; the work focuses on inference serving, benchmarking and system-level optimization rather than building predictive models.
Evidence
llm-cpu-inference-optimization/eval_client.py
Business Insight & Impact
4/10
Turning analysis into business value
Strong operational framing and product thinking (multi-tenancy, RBAC, quotas, SLA-focused metrics and audit chains) tie technical work to business impact; cost/error tradeoffs are documented at the infra level rather than as an explicit business-A/B analysis.
Evidence
production-llm-platform/demo/render_video.py
production-llm-platform/docs/09_Scaling_Reliability_Design.md
Reproducibility & Notebook Hygiene
7/10
Clean, repeatable analysis
Good reproducibility practices are evident: pinned requirements, extensive unit tests, test fixtures, and CI badges; experiment results and scripts are committed for reproducibility.
Evidence
production-llm-platform/requirements.txt
production-llm-platform/backend/tests/conftest.py
production-llm-platform/backend/tests/test_enterprise_apis.py
Expertise
Data Science• Middle
Streaming• Middle
Technologies
PostgreSQL
Redis
LLM• since 2026
LLMOps
Llama• mentioned only
llama.cpp• mentioned only
MLOps• mentioned only
Quantization• mentioned only
vLLM• mentioned only
Recommendations
- Design and implement production LLM inference services including streaming (SSE), replica management, circuit breakers, and health-aware routing.
- Build multi-tenant API platforms with RBAC, rate limiting and quota enforcement that require secure key management and auditability.
- Lead performance benchmarking and reproducible CPU/GPU inference optimization experiments with automated result collection and analysis.
- Implement scalable background writers, tenant-safe cache patterns, and observability pipelines (Prometheus metrics, structured audit logs).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: Medium API Engineer
Senior backend engineer (approx mid/early senior level) specializing in production LLM serving and multi-tenant FastAPI platforms. The strongest proven skill is building enterprise multi-tenant auth, RBAC and API gateway behavior with comprehensive tests (see backend/tests/test_enterprise_*.py). Public artifacts do not show low-level distributed storage consensus work, long migration histories, or extensive load-test result artifacts.
API Design
6/10
How well APIs are designed
API contracts, error handling and endpoint behavior are well-tested and consistent across routes, but explicit versioning/pagination/idempotency patterns are not strongly visible in the human-authored artifacts.
Evidence
production-llm-platform/backend/tests/test_enterprise_apis.py: comprehensive tests for organization/project/membership endpoints, status codes and error paths
production-llm-platform/backend/tests/test_gateway_generate.py: generate/streaming endpoint behaviour and error paths (referenced in tests list)
production-llm-platform/backend/tests/test_enterprise_tenant_isolation.py: tests asserting API-layer tenant-boundary enforcement
Data Layer & Database
5/10
Working with databases
Schema and integrity constraints are exercised by unit tests (FKs, unique constraints) and migrations are present, but there is limited human-authored evidence of a long migration history, tuned SQL, or explicit transaction/isolation-level decisions.
Evidence
production-llm-platform/backend/tests/test_enterprise_db.py: asserts on models (APIKey, Membership, UsageQuota, FK existence and relationships)
production-llm-platform/backend/tests/test_enterprise_tenant_isolation.py: checks for unique constraints and foreign keys in models
production-llm-platform/alembic/versions/001_initial.py (listed in repo metadata): initial migration file presence
Scalability & Performance
4/10
Handling load and speed
There is evidence of scaling and performance consideration (replica/queue/circuit-breaker concepts in docs and tests, and a CPU inference experiment), but measured optimization artifacts and production load-test data are not prominent within the human-authored files analyzed here.
Evidence
production-llm-platform/demo/render_video.py: scenes describing scaling, circuit breaker, retry/backoff and queue behavior
llm-cpu-inference-optimization/speculative-decoding/code/speculative_server.py: experimental server demonstrating measured CPU inference experiments
production-llm-platform/backend/tests/test_enterprise_tenant_isolation.py: tests for rate-limiting and cache key formats
System Architecture
5/10
Overall system structure
Clear modular separation and deliberate architecture choices are documented and exercised by tests (gateway, inference, enterprise modules, middleware), though some decomposition decisions are primarily reflected in tests/docs rather than large, complex multi-service integration code in the human-authored subset.
Evidence
production-llm-platform/demo/render_video.py: architecture scenes that enumerate Gateway, Inference, Auth, DB, Redis and middleware chain
production-llm-platform/backend/tests/test_enterprise_apis.py: tests that exercise gateway/enterprise route boundaries
production-llm-platform/backend/tests/test_enterprise_tenant_isolation.py: tests enforcing tenant boundaries across services
Security & Auth
6/10
Protecting data and access
Strong, concrete security and auth work is evidenced: JWT claim handling, API key hashing, bcrypt usage and many tests for auth flows and tenant-safe caching; token lifecycle and revocation are implemented/tested at the API level.
Evidence
production-llm-platform/backend/tests/test_enterprise_auth.py: JWTService tests for encoding/decoding and enterprise claims
production-llm-platform/backend/tests/test_enterprise_apis.py: API key generation/list/revoke flows tested for correct responses
production-llm-platform/backend/tests/test_enterprise_tenant_isolation.py: tests verifying API key cache key uses SHA-256 hash and cache isolation
Reliability & Observability
5/10
Stability and monitoring
Observability and reliability are covered with Prometheus metric assertions, audit logging/hash-chain tests and background writer behaviour in tests; production SLO/SLI specifics and exhaustive operational runbooks are not part of the human-authored files analyzed.
Evidence
production-llm-platform/backend/tests/test_enterprise_db.py: audit log model and audit service tests
production-llm-platform/backend/tests/test_enterprise_tenant_isolation.py: tests asserting Prometheus metrics label design
production-llm-platform/demo/render_video.py: scenes describing metrics, dashboards, audit background writer and monitoring
Expertise
Backend AI & LLM• Middle
Microservices & API Architecture• Middle
Python• Middle
System Architecture• Middle
Databases & Vector Storage• Middle
Industries
Artificial Intelligence• Middle
Software• Middle
Technologies
Python• since 2025 • Senior
Node JS• Senior
Rest API
SQLAlchemy
FastAPI
Bcrypt
Asyncio
Pydantic
HTTPX
Uvicorn
Alembic
Recommendations
- Lead development of API gateway, auth and RBAC features for multi-tenant LLM services, including endpoint contracts and error semantics.
- Implement or extend inference scaling components (replica manager, queueing, circuit breakers) and add measured load-testing and performance benchmarks.
- Hardening of DB migration practices: add explicit migration chains, documented rollback strategies and review transaction/isolation decisions for high-concurrency paths.
- Expand operational observability by codifying SLIs/SLOs, alerting rules and measuring end-to-end request traces for inference pipelines.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: