Arpit Somani
Software Developer
4+ years exp
4+ years ML exp
JavaScript
Python
SQL
MLOps & Deployment: 6/10
Data Pipeline & Feature Engineering: 5/10
Model Architecture & Training: 4/10
Active 3 days ago
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
LLM/MLOps Engineer (senior level) specializing in production RAG and multi-tenant AI system design with strong operational and schema-driven engineering focus. The strongest proven skill is building production-grade multi-tenant inference and RAG plumbing as evidenced by app/core/orchestrator.py, app/rag_engine/pinecone_client.py and FastAPI route handlers. Public code lacks custom deep-learning training loops, experiment tracking (W&B/MLflow) and demonstrated low-level GPU optimization implementations.
Phone
Technical skills
Languages
3
JavaScript
Python
SQL
Python
6
Flask
Requests
Pydantic
Celery
FastAPI
Uvicorn
AI/ML
16
Scikit-learn
Llama
YOLO
OpenAI
RAG
Embeddings
Pandas
NumPy
LightGBM
LLM
LangChain
LangGraph
PyTorch
TensorFlow
NLTK
Copilot
DevOps
5
AWS
Azure
Rest API
Docker
Git
Frontend
3
React.js
Bootstrap
JQuery
Other
11
Pinecone
Pytest
Postman
AI Agents
ONNX
Frontend
Multimodal AI
Semantic Search
Computer Vision
NLP
Anomaly Detection
Projects
Fashion AI Copilot
Designed and led an agentic multimodal platform for fashion design search using image and text with hybrid retrieval. Created autonomous agents to extract trend intelligence and generate data-driven recommendations for product teams. Implemented a generative pipeline for virtual apparel edits and related visualization using diffusion and vision foundation models.
Hybrid AI Engine
Built a zero-to-one multi-tenant hybrid ML and RAG platform with dynamic input/output schemas. Implemented automated training using classical ML and a fallback RAG approach for cold-start scenarios and unstructured queries using LLMs with vector search.
Timeline
Software Engineer
·
Middle
Pratham Software
·
Full-Time
Led AI/ML initiatives for predictive modeling and enterprise AI scaling. Architected and deployed production LLM and RAG systems to improve retrieval relevance and response quality for business use cases. Built agentic AI workflows integrating GPT/Llama with vector databases for automated reasoning and decision support, and implemented end-to-end RAG for semantic search. Delivered a real-time computer vision anomaly detection pipeline using YOLO.
OpenAI
Llama
Pinecone
RAG
YOLO
AWS
Azure
Rest API
Embeddings
Associate Software Engineer
·
Middle
Pratham Software
·
Full-Time
Developed backend services and REST APIs using Flask while applying an onion architecture approach. Designed and deployed a multi-tenant, configurable classification system using modular preprocessing pipelines. Built and tuned traditional machine learning models with scikit-learn for adaptable model architectures.
Flask
Scikit-learn
Rest API
Swami Keshvanand Institute of Technology, Management and Gramothan (SKIT)
Bachelor's Degree ·
Computer Science and Engineering
Software Engineer Trainee
·
Junior
Pratham Software
·
Internship
Designed and developed a web application for resume creation and management using ReactJS with a Flask backend. Implemented APIs to process user inputs and generate customized, dynamic resumes. Coordinated with frontend development to deliver a usable and visually focused user experience.
JavaScript
Flask
Rest API
Middle AI/ML Engineer
Confidence: Low LLM Engineer
LLM/MLOps Engineer (senior level) specializing in production RAG and multi-tenant AI system design with strong operational and schema-driven engineering focus. The strongest proven skill is building production-grade multi-tenant inference and RAG plumbing as evidenced by app/core/orchestrator.py, app/rag_engine/pinecone_client.py and FastAPI route handlers. Public code lacks custom deep-learning training loops, experiment tracking (W&B/MLflow) and demonstrated low-level GPU optimization implementations.
Model Architecture & Training
4/10
How well models are designed and trained
Solid ML pipeline and AutoML work (LightGBM, Optuna) and a clear training/predict flow for tabular models, but no custom deep-learning training loops, loss engineering, or novel architectures implemented.
Evidence
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/ml_engine/trainer.py
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/ml_engine/optimizer.py
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/ml_engine/registry.py
Data Pipeline & Feature Engineering
5/10
How data is prepared for models
Concrete data ingestion, schema validation, and preprocessing components with multi-tenant paths and dynamic schema registry; shows attention to training-serving skew and feature handling.
Evidence
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/api/routes/data.py
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/ml_engine/preprocessor.py
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/schema_engine/registry.py
Experimentation & Evaluation
4/10
How results are measured and tested
Uses Optuna for hyperparameter search and includes metric computations and tests; lacks integrated experiment tracking (W&B/MLflow) or large-scale reproducibility artifacts.
Evidence
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/ml_engine/optimizer.py
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/ml_engine/trainer.py
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/tests/test_ml_pipeline.py
MLOps & Deployment
6/10
How models are shipped to production
Clear MLOps and deployment focus: FastAPI endpoints, multi-tenant isolation, model registry, RAG plumbing (Pinecone client mock/manager), orchestrator and test coverage for API and orchestrator flows.
Evidence
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/main.py
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/core/orchestrator.py
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/rag_engine/pinecone_client.py
Computational Efficiency
3/10
How efficiently computing resources are used
Some awareness of efficiency (batching, embedding dimensions, mock index, caching) but no implemented low-level GPU optimizations, CUDA/TensorRT integrations or demonstrated quantization work in code.
Evidence
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/app/rag_engine/embedder.py
Hybrid-AI-Engine---Multi-Tenant-Dynamic-ML---RAG-Solution/scripts/run_benchmark.py
The-Era-of-AI/scripts/build_full_curriculum_part4.py (concept descriptions about dynamic batching and caching - design evidence)
Research Depth & Innovation
2/10
Depth of research and new ideas
High-quality domain knowledge and conceptual research notes are present (curriculum content), but little evidence of novel research code, paper reproductions, or custom model layers/algorithms in production code.
Evidence
The-Era-of-AI/scripts/add_comprehensive_curriculum.py (extensive conceptual content)
The-Era-of-AI/scripts/build_full_curriculum_part4.py
Expertise
RAG· Middle
MLOps & Model Lifecycle· Middle
Industries
Artificial Intelligence· Middle
Technologies
SQL
Copilot
LangGraph
LangChain
Pinecone· since 2023
YOLO· since 2023
Embeddings· since 2023
Scikit-learn· since 2022
Multimodal AI
Computer Vision· since 2026
AI Agents
NLP· since 2026
LightGBM
ONNX
Azure· since 2023
Llama· since 2023
TensorFlow
Pandas
NumPy
Git
PyTorch
AWS· since 2023
Docker
LLM
RAG· since 2023
NLTK
Requests
Anomaly Detection
OpenAI· since 2023
Semantic Search
GitHub· mentioned only
Recommendations
- Implement or link an experiment tracking system (MLflow or W&B) and add reproducible run artifacts for hyperparameter trials
- Add explicit production deployment manifests and CI/CD snippets (Kubernetes/Helm, GitHub Actions) and hardened secrets handling for tenant isolation
- Provide at least one custom training loop or model-fine-tuning example (e.g. LoRA + quantization pipeline) with before/after metrics to demonstrate model engineering depth
- Add documented performance benchmarks for inference backends (latency/P95/P99, GPU utilization) and a small guide for dynamic batching and model caching configuration
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: Low Generalist
A practical AI/ML content and tooling developer at a junior-to-middle level focusing on MLOps and GenAI system design content. The developer's strongest proven skill is producing detailed, production-oriented ML and GenAI curriculum and design artifacts as implemented across multiple Python scripts that build and serialize structured concept/topic JSON. There is limited public evidence of implemented production backend systems, transaction-safe data layers, or deployed API/service code and observability instrumentation.
API Design
2/10
How well APIs are designed
Minimal API design engineering; mostly educational content describing API tradeoffs (FastAPI vs Flask) rather than implemented, versioned API contracts or idempotency handling.
Evidence
The-Era-of-AI/scripts/build_full_curriculum_part4.py: new_concepts entry 'concept_rest_api_fastapi_vs_flask' describing FastAPI vs Flask tradeoffs and ASGI/Uvicorn
The-Era-of-AI/scripts/build_full_curriculum_part4.py: 'concept_fastapi_llm_serving' entry discussing streaming endpoints and SSE patterns
Data Layer & Database
2/10
Working with databases
Data-layer work is limited to JSON file read/write and content generation; no migration history, transaction boundaries or tuned queries are implemented in the analyzed human-authored files.
Evidence
The-Era-of-AI/scripts/add_comprehensive_curriculum.py: reads/writes src/data/concepts.json and src/data/topics.json
The-Era-of-AI/scripts/build_full_curriculum_part4.py: writes to src/data/concepts.json and constructs many concept objects serialized to JSON
Scalability & Performance
2/10
Handling load and speed
Scalability and performance topics are well understood in prose, but there is no production-grade implementation of caching, dynamic batching, or connection-pooling logic in the human-authored code reviewed.
Evidence
The-Era-of-AI/scripts/build_full_curriculum_part4.py: 'concept_system_design_multitenant_ml_platform' discusses dynamic batching and GPU utilization
The-Era-of-AI/scripts/build_full_curriculum_part4.py: 'concept_semantic_caching_latency_cost' describing semantic caching and Redis TTLs
System Architecture
2/10
Overall system structure
System architecture knowledge is expressed as curriculum content (Onion architecture, multi-tenant design) but there is little evidence of the developer implementing service decomposition, config/secret management, or graceful degradation in runnable backend code in the analyzed files.
Evidence
The-Era-of-AI/scripts/build_full_curriculum_part4.py: 'concept_onion_clean_architecture_ml' covering Onion/Clean Architecture and ports/adapters
The-Era-of-AI/scripts/build_full_curriculum_part4.py: 'concept_multitenant_ai_architecture' covering tenant isolation, rate limiting and model routing
Security & Auth
2/10
Protecting data and access
Security concepts (guardrails, RBAC, tenant isolation) are thoroughly documented in the content, but concrete implementations (token lifecycle, input validation middleware, secret handling) are not present in the human-authored scripts examined.
Evidence
The-Era-of-AI/scripts/build_full_curriculum_part4.py: 'concept_guardrails_safety_hallucination' describing input/output guardrails and jailbreak detection
The-Era-of-AI/scripts/build_full_curriculum_part4.py: 'concept_multitenant_ai_architecture' which outlines tenant namespaces and encryption recommendations
Reliability & Observability
2/10
Stability and monitoring
Reliability and observability are addressed at the conceptual level (testing strategy, CI/CD, canary deployments) but there is no direct evidence of instrumentation, structured logging, retries with backoff, or production observability code in the analyzed human-authored files.
Evidence
The-Era-of-AI/scripts/build_full_curriculum_part4.py: 'concept_pytest_testing_strategy_ml' describing PyTest fixtures, mocking and CI practices
The-Era-of-AI/scripts/build_full_curriculum_part4.py: 'concept_git_cicd_model_release_hygiene' describing CI/CD pipelines, canary releases and model release hygiene
Expertise
Backend AI & LLM· Junior
Python· Junior
Microservices & API Architecture· Junior
Industries
Artificial Intelligence· Middle
Software· Junior
Technologies
Python· Middle
Rest API· since 2022
Flask· since 2022
FastAPI· since 2026
Celery
Pydantic
Uvicorn
Stack· mentioned only
Recommendations
- Implement a small production FastAPI service that wires one of the documented designs into runnable endpoints (with timed timeouts, idempotency keys, and Pydantic request/response models).
- Build an end-to-end RAG ingestion demo using a vector store and tenant isolation (ingest pipeline, namespace filtering, RBAC enforcement, and integration tests).
- Add CI-driven tests and observability: unit/integration tests (pytest), structured logs with correlation ids, metrics (Prometheus) and a canary deployment pipeline for model releases.
- Convert curriculum content into automated validation tooling (schema-driven validators, contract tests, and example API contracts/Newman collections) to close the gap between documentation and runnable systems.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium UI Engineer
Frontend/UI developer at a junior level specializing in building Bootstrap-based responsive marketing and small storefront pages. The strongest proven skill is producing polished static UIs using Bootstrap and custom CSS as shown in the index.html and css/style.css pages across the projects. There is little evidence of component architecture, automated testing, backend integration, or measured performance and accessibility processes.
UI Component Architecture
2/10
How interface parts are built
Componentization is minimal; pages are static HTML using Bootstrap with custom CSS rather than reusable component architecture or a design-system built by the author.
Evidence
Business-Website-Bootstrap/index.html: monolithic page structure using Bootstrap classes (no component boundaries)
Men-Cloth-Website-Bootstrap/index.html: repeated card and navbar markup rather than extracted components
Responsive & Cross-browser
3/10
Works on all screens and browsers
Responsive layout relies on Bootstrap grid and CSS media queries; basic responsive patterns are present but no advanced techniques or explicit cross-browser feature-detection.
Evidence
Men-Cloth-Website-Bootstrap/css/style.css: multiple @media rules adjusting carousel and layout heights
Coffee-Website-Bootstrap/index.html: viewport meta and Bootstrap grid usage for responsive behaviour
Performance Optimization
1/10
Speed of the interface
No measured performance work or build-time optimization; usage is CDN-hosted Bootstrap and jQuery without code-splitting, lazy-loading, or bundle analysis artifacts.
Evidence
Business-Website-Bootstrap/index.html: Bootstrap and jQuery pulled from CDNs (no build pipeline evidence)
Coffee-Website-Bootstrap/css/style.css: bg-video and image handling present but no lazy-loading or optimization strategy
Accessibility & Semantics
2/10
Usable for everyone
Some semantic and ARIA usages exist (aria-labels, sr-only), but accessibility is inconsistent and there is no evidence of a11y testing or custom accessible widgets.
Evidence
Business-Website-Bootstrap/index.html: navbar toggler includes aria-label and uses sr-only for carousel controls
Coffee-Website-Bootstrap/index.html: form inputs include labels and aria-describedby on email input
State Management & Data Flow
1/10
Managing data in the app
No non-trivial state management or server-state discipline; only small UI scripts and initializations (jQuery scroll handler and SmoothScroll init) with no request cancellation, optimistic updates, or state machines.
Evidence
Men-Cloth-Website-Bootstrap/index.html: inline jQuery scroll handler toggling navbar background
Business-Website-Bootstrap/index.html: initialization call 'var scroll = new SmoothScroll("a[href*='#']");' (library usage only)
UX & Visual Polish
3/10
Look and feel quality
Pages show visual polish for static content - carousels, animated classes and hover effects improve perceived UX, but there are no advanced UX patterns like skeleton loading, undo, or progressive enhancement strategies.
Evidence
Business-Website-Bootstrap/index.html: Bootstrap carousel and progress bars for skills
Men-Cloth-Website-Bootstrap/index.html: wow.js animations and animated product cards
Verified artifacts
Expertise
HTML & CSS· Junior
Industries
Commerce· Junior
Technologies
Frontend
Bootstrap
React.js
JQuery
Recommendations
- Build marketing landing pages and small e-commerce frontends using Bootstrap or convert them into component-based frameworks (React/Vue) to enable reuse and testing.
- Own accessibility and testing improvements - add automated a11y checks, form validation, and keyboard focus management for custom interactions.
- Add lightweight performance practices - image optimization, lazy-loading, and a simple build pipeline to enable asset versioning and bundle analysis.
- Incrementally refactor repeated UI blocks into reusable components and document a simple style/token system to scale multiple templates.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: