Sahil Pawar
Node JS
Python
Model Architecture & Training: 4/10
Data Pipeline & Feature Engineering: 4/10
Experimentation & Evaluation: 4/10
Active 6 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Roles
Overview
Backend API engineer building LLM-backed data-extraction and multimedia-forensics services with thoughtful service decomposition and evaluation-driven design. The strongest proven skill is engineering production LLM and vector search integrations as shown by the HealthScribe rag_chain.py, ai_service/main.py extraction and embedding endpoints and the evaluation harness in ai_service/evaluate.py. There is limited public evidence of production-grade operationalization like token revocation, centralized metrics/tracing or formal load-testing artifacts.
Technical skills
Node JS• Middle
Python• Senior
Node JS
Axios
Express
Mongoose
Python
FastAPI
Django
Django REST Framework
Pydantic
Uvicorn
SQLAlchemy
Databases
PostgreSQL
pgvector
FAISS
AI/ML
LangChain
OpenCV
BERT
Google GenAI SDK
OpenAI SDK
Pandas
NumPy
Scikit-learn
huggingface_hub
Frontend
React.js
Vite
Tailwind CSS
React Router
Framer Motion
Recharts
Senior AI/ML Engineer
Confidence: High LLM Engineer
LLM-focused engineer (mid-senior level) specializing in building retrieval-augmented and multi-agent LLM pipelines with applied computer vision integration. The strongest proven skill is architecting agentic RAG/LLM workflows and production orchestration as shown by the LangGraph-based orchestrator and the FastAPI background processing + SSE job pipeline. Public code does not demonstrate low-level GPU/quantization optimization, large-scale distributed training, or long-running experiment tracking for reproducible hyperparameter sweeps.
Model Architecture & Training
4/10
How well models are designed and trained
Practical model training and tuning evidence including a custom BERT training loop, optimizer/scheduler choices, layer-freezing ablations and evaluation on held-out test sets.
Evidence
Innomatics-/IN226063502/GEN_AI/TASK4_BERT.ipynb: run_experiment / train_epoch / evaluate_epoch (custom training loop, optimizer, scheduler, freeze modes)
Innomatics-/IN226063502/GEN_AI/Task5.ipynb: tokenize_and_align_labels and Trainer setup (token-classification training using Hugging Face Trainer)
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Multiple data preparation pipelines are present for text and video including tokenization/label-alignment, document chunking for RAG, TF-IDF/Word2Vec feature engineering and frame extraction/downscaling for video.
Evidence
Innomatics-/IN226063502/RAG_FINAL_PROJECT/src/chunker.py: split_documents (document chunking for RAG)
VeriFrame/backend/preprocessing.py: extract_frames, downscale_video (frame extraction, downscaling)
Innomatics-/IN226063502/NLP/sentiment_analysis.ipynb: preprocessing and TF-IDF / Word2Vec feature engineering
Experimentation & Evaluation
4/10
How results are measured and tested
Experimentation and evaluation artifacts include train/val/test splits, metric reporting, plots, and an explicit evaluation step; some experiments compare ablations (freeze modes) and record best-model state.
Evidence
Innomatics-/IN226063502/GEN_AI/TASK4_BERT.ipynb: train/val/test splitting, print_metrics, experiment comparison and plotting
Innomatics-/IN226063502/GEN_AI/Task5.ipynb: compute_metrics and Trainer evaluation
VeriFrame/backend/evaluate_pipeline.py: run_evaluation (pipeline evaluation harness)
MLOps & Deployment
4/10
How models are shipped to production
Clear MLOps and deployment engineering including a FastAPI service, background processing of jobs, SSE event streaming, DB persistence, rate limiting, and vector-store creation for RAG ingestion.
Evidence
VeriFrame/backend/main.py: FastAPI endpoints, background_tasks, upload processing, SSE stream_job_events, and DB job lifecycle
VeriFrame/backend/agents/orchestrator.py: run_pipeline and compiled langgraph workflow used at runtime
Innomatics-/IN226063502/RAG_FINAL_PROJECT/src/vector_store.py and src/main.py: vector store creation/load and add/ask CLI
Computational Efficiency
3/10
How efficiently computing resources are used
Some computational-efficiency work is evident - downscaling video, extracting frames in-memory, and selective fine-tuning (freeze layers) to reduce trainable parameters and latency; however there is no deep GPU profiling, quantization or distributed training evidence.
Evidence
VeriFrame/backend/preprocessing.py: downscale_video and extract_frames (compute and I/O optimizations)
Innomatics-/IN226063502/GEN_AI/TASK4_BERT.ipynb: freeze_mode experiments that report trainable param counts
VeriFrame/backend/agents/orchestrator.py: router_node that skips LLM to save latency when CV agents are confident
Research Depth & Innovation
4/10
Depth of research and new ideas
Architectural and research-minded choices appear - a multi-agent LangGraph orchestration with conditional routing, cyclic reflection loops for self-correction and HITL escalation indicates thoughtful design and some innovation in system architecture.
Evidence
VeriFrame/backend/agents/orchestrator.py: conditional routing, reflection loop, synthesis and LLM integration (multi-agent architecture)
Innomatics-/IN226063502/RAG_FINAL_PROJECT/src/langgraph_workflow.py: AgentState, routing_logic and HITL escalation hooks
Innomatics-/IN226063502/GEN_AI/TASK4_BERT.ipynb: ablation comparing freeze modes with metric comparison and plots
Expertise
AI / LLM Engineering (Agents)• Senior
RAG• Middle
Computer Vision & Image Analysis• Middle
Industries
Cybersecurity• Senior
Technologies
Python• Senior
LangChain
OpenCV
FAISS
SQLAlchemy
FastAPI
Scikit-learn
Google GenAI SDK
OpenAI SDK
huggingface_hub
Pandas
NumPy
BERT
Recommendations
- Design and deploy production RAG systems and agent orchestration where conditional routing, HITL escalation and latency budgets matter.
- Build multi-agent vision-LLM forensics or moderation tools that combine the existing CV modules with LLM reasoning and reporting pipelines.
- Implement evaluation-driven fine-tuning and ablation studies with reproducible experiment tracking (W&B/MLflow) to strengthen model-evaluation credibility.
- Harden MLOps pipelines with quantization, GPU profiling and CI/CD for model artifacts and vector stores to improve efficiency and reliability.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Backend Developer
Confidence: High API Engineer
Backend API engineer building LLM-backed data-extraction and multimedia-forensics services with thoughtful service decomposition and evaluation-driven design. The strongest proven skill is engineering production LLM and vector search integrations as shown by the HealthScribe rag_chain.py, ai_service/main.py extraction and embedding endpoints and the evaluation harness in ai_service/evaluate.py. There is limited public evidence of production-grade operationalization like token revocation, centralized metrics/tracing or formal load-testing artifacts.
API Design
5/10
How well APIs are designed
Reasonable API design with JWT flows, rate limiting, clear HTTP status usage and SSE streaming; lacks explicit versioning, idempotency keys, pagination and formal error contract standardization across services.
Evidence
HealthScribe/ai_service/main.py: use of slowapi Limiter decorators and FastAPI endpoints (extract_data, chat, embed_record)
HealthScribe/backend/api/views.py: CustomTokenObtainPairView and well-formed HTTP responses in RegisterView/ProfileView/SaveRecordView
VeriFrame/backend/main.py: SSE streaming endpoint stream_job_events and rate limit handler (RateLimitExceeded -> 429)
Data Layer & Database
5/10
Working with databases
Data layer shows conscious choices - migrations, Django models, fallback strategies for vector store and Postgres usage; however there is limited evidence of explicit transaction boundary management, isolation-level control or hand-tuned SQL/index optimizations.
Evidence
HealthScribe/backend/api/models.py: domain models (MedicalRecord, HealthEntity, UserProfile) and accompanying migrations under backend/api/migrations/
HealthScribe/ai_service/rag_chain.py: init_chat_table uses psycopg2 to create chat_history and PGVector/Chroma fallback logic
VeriFrame/backend/database.py: SQLAlchemy engine/session scaffolding and create_tables usage
Scalability & Performance
5/10
Handling load and speed
Several practical scalability and performance patterns are present - rate limiting, background workers, video downscaling, SSE event streaming and routing decisions to avoid expensive LLM work; there is no evidence of a full queuing system, cache invalidation strategy or measured load-testing artifacts.
Evidence
VeriFrame/backend/main.py: background_tasks.add_task(process_video_task, ...) with downscaling and background processing
HealthScribe/ai_service/main.py: limiter usage and conditional hybrid/gemini engine selection to trade accuracy vs latency
VeriFrame/backend/agents/orchestrator.py: router_node makes runtime routing decisions to skip LLM to optimise latency
System Architecture
6/10
Overall system structure
Clear service decomposition (ai_service vs backend), thoughtful fallback strategies (PGVector vs Chroma), and a deliberate multi-agent workflow design using langgraph with conditional and cyclic edges; the decomposition looks purposeful rather than microservices-for-show.
Evidence
VeriFrame/backend/agents/orchestrator.py: langgraph StateGraph design with conditional routing, reflection loop and compiled workflow
HealthScribe/ai_service/rag_chain.py: vectorstore selection (PGVector vs Chroma) and chat history Postgres/JSON fallback
Project layout: separate FastAPI ai_service for LLM work and Django backend API for user records and auth
Security & Auth
6/10
Protecting data and access
Authentication and input-boundary checks are implemented - JWT-based flows, password hashing, pydantic schemas, file type/size validations and request timeouts; missing evidence for token revocation, stricter secret management and service-level auth on internal AI endpoints.
Evidence
HealthScribe/backend/api/views.py: issues and responses around authentication; CustomTokenObtainPairView integration with simplejwt
VeriFrame/backend/auth.py: password hashing, JWT creation and get_current_user dependency
HealthScribe/ai_service/main.py: Pydantic request models, file type and MAX_FILE_SIZE checks, and request timeouts for external calls
Reliability & Observability
6/10
Stability and monitoring
Solid reliability and observability practices - structured logging, exception handling, retries/backoff in evaluation harness, graceful cleanup of background tasks and job status updates; lacks explicit metric exports or centralized tracing but uses defensive try/except and job-status signaling.
Evidence
HealthScribe/ai_service/evaluate.py: run_eval includes retries, exponential backoff behavior and detailed logging of errors and rate-limit handling
VeriFrame/backend/main.py: process_video_task uses try/except/finally and event_bus.mark_failed/mark_completed to reflect job state
Multiple modules (rag_chain.py, ai_service/main.py, backend/api/views.py): pervasive logger.exception and logging usage for failures
Verified artifacts
Expertise
Backend AI & LLM• Senior
Databases & Vector Storage• Middle
Messaging & Real-time• Middle
Microservices & API Architecture• Middle
Python• Senior
Industries
Health Care• Middle
Media & Entertainment• Senior
Technologies
PostgreSQL
pgvector
Django
Pydantic
Uvicorn
Django REST Framework
Recommendations
- Develop and harden authenticated service-to-service authorization for AI endpoints (embed/delete/chat) and add token revocation or client credentials.
- Add metrics and tracing (Prometheus/OpenTelemetry) and a simple load-test benchmark to measure latency and resource usage of the RAG/embedding pipeline.
- Introduce an explicit idempotency scheme and pagination for API endpoints that create or list resources; consider moving background jobs to a durable queue (e.g. Celery/RabbitMQ) for scale.
- Add database transaction boundaries where multiple write operations must be atomic and document expected isolation assumptions for key flows.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium Fullstack
Fullstack web developer at an early middle level specializing in building React frontends and simple Node/Express backends with pragmatic UX polish. The strongest proven skill is implementing user-facing React flows and upload/AI integration UIs as shown in CampusKart pages like SellItem.js and HealthScribe frontend upload/verify UI assets. There is limited evidence of advanced state-machine design, formal performance measurement, or automated test coverage in the public code.
UI Component Architecture
4/10
How interface parts are built
Reasonable component boundaries across React pages and use of context and api modules, but no evidence of a bespoke component library, design tokens, or advanced composition patterns.
Evidence
CampusKart/campuskart_frontend/src/pages/SellItem.js
CampusKart/campuskart_frontend/src/pages/Gigs.js
CampusKart/campuskart_frontend/src/context/AuthContext.js
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive layouts and mobile breakpoints are implemented via CSS and Tailwind configuration, but no advanced cross-browser feature detection or explicit RTL/i18n scaffolding.
Evidence
HealthScribe/frontend/src/App.css
CampusKart/campuskart_frontend/tailwind.config.js
HealthScribe/frontend/index.html
Performance Optimization
2/10
Speed of the interface
Uses modern bundlers (Vite) and keeps dependencies up to date, but lacks measured performance work, code-splitting evidence, virtualization, or bundle analysis artifacts.
Evidence
HealthScribe/frontend/vite.config.js
HealthScribe/frontend/package.json
Accessibility & Semantics
3/10
Usable for everyone
Some accessibility-conscious practices (sr-only labels, alt attributes, descriptive titles) appear in forms and images, but no ARIA on custom widgets, focus management, or a11y toolchain evidence.
Evidence
CampusKart/campuskart_frontend/src/pages/Register.js
CampusKart/campuskart_frontend/src/pages/SellItem.js
CampusKart/campuskart_frontend/src/pages/Marketplace.js
State Management & Data Flow
3/10
Managing data in the app
Standard React state and server calls with try/catch and loading states, AuthContext for shared state, but no advanced server-state discipline like cancellations, optimistic rollbacks, or state machines.
Evidence
CampusKart/campuskart_frontend/src/pages/Gigs.js
CampusKart/campuskart_frontend/src/pages/SellItem.js
CampusKart/campuskart_frontend/src/pages/Marketplace.js
UX & Visual Polish
5/10
Look and feel quality
Strong visual polish and UX details are present including loading, empty states, modals and microcopy; the work shows attention to perceived performance and user flows.
Evidence
HealthScribe/frontend/src/App.css
CampusKart/campuskart_frontend/src/pages/Gigs.js
CampusKart/campuskart_frontend/src/pages/Marketplace.js
Expertise
React• Middle
HTML & CSS• Middle
Frontend Architecture & Build Tools• Middle
Frontend AI Integration• Middle
Industries
Commerce• Middle
Education• Middle
Health Care• Middle
Technologies
Node JS• Middle
Tailwind CSS
Express
React.js
Vite
Mongoose
Axios
Framer Motion
Recharts
React Router
Recommendations
- Develop React SPA features and end-to-end user flows that integrate with REST APIs, such as upload, analyze, review and persist patterns.
- Implement and harden AI-assisted UX flows - focus on validation, retry/cancellation, clear error states and rollback strategies for extract-and-save interactions.
- Invest in test coverage and state discipline - add unit/integration tests, introduce cancellation or request deduplication patterns, and consider state machines for multi-step flows.
- Work on measurable performance improvements - add bundle analysis, code-splitting, and lazy loading for large pages or charts.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: