Shiva Manish Gajadi
AI Engineer
Python
JavaScript
Node JS
SQL
C++
TypeScript
MLOps & Deployment: 4/10
Computational Efficiency: 4/10
Active 10 hours ago
Invite to interview
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
A mid-level API-focused developer building lightweight ML inference services and web demos. The strongest proven skill is deploying an ML inference endpoint with practical memory and performance choices such as quantization, chunking, and per-chunk cleanup in backend-ai-detector/main.py. Production-ready concerns are not evidenced: there is no auth, no structured observability, no DB migrations, and CORS and secret handling are weak.
Phone
Technical skills
Languages
6
Python
JavaScript
Node JS
SQL
C++
TypeScript
AI/ML
17
Gemini
LangChain
ElevenLabs
OpenAI
Groq
Transformers
Scikit-learn
Pandas
NumPy
Deepgram
RAG
LLM
Llama
Hugging Face
CUDA
PyTorch
Whisper
Databases
4
Redis
FAISS
Milvus
PostgreSQL
DevOps
14
Kubernetes
Amazon EKS
Docker
AWS
WebRTC
WebSockets
Amazon S3
Amazon EC2
AWS Lambda
Cloudflare
OpenTelemetry
Rest API
GitHub
GitHub Actions
Frontend
3
React.js
Tailwind CSS
React Router
Other
24
Celery
Auth0
FastAPI
Playwright
Datadog
Linux
PostCSS
Twilio
AI Agents
llama.cpp
Machine Learning
CI/CD
Quantization
Prompt Engineering
Embeddings
Structured Outputs
autoprefixer
LLM Guardrails
Text-to-Speech
Voice Agents
NLP
Tokenization
CNN
GAN
Projects
Frame-by-Frame Video Prediction
Implemented a temporal video frame prediction model using a CNN-LSTM architecture with adversarial training. Evaluated prediction quality using standard image similarity metrics such as SSIM and PSNR. Trained and tested the model to reach the reported frame-level accuracy.
On-Device Voice LLM Agent
Built a fully local voice agent that runs STT, LLM reasoning, and TTS on-device to avoid cloud inference costs. Designed it to accept inbound PSTN calls and execute spoken commands by controlling physical hardware. Used local models and network tunneling components to connect the caller to the on-device system.
Timeline
AI Engineer
•
Middle
Circuitry AI
•
Full-Time
Owned a production LLM voice agent for vehicle claims intake, integrating real-time policy retrieval and claimant verification during live calls. Implemented multi-turn dialogue state machines for structured data extraction with resilient tool-calling orchestration and SSE streaming. Added per-session token and model usage logging to support cost attribution and benchmarking.
FastAPI
Python
RAG
Structured Outputs
Software Engineer, AI & Voice Systems
•
Middle
CloudBuilders
•
Full-Time
Architected an LLM agent platform supporting 500+ concurrent sessions with low time-to-first-token using WebRTC and WebSockets. Built an agentic RAG stack with LangChain, Milvus, FAISS, and a Redis semantic cache, and implemented async ingestion with Celery. Developed a provider-agnostic model layer across OpenAI, Groq, Gemini, Deepgram, and ElevenLabs, and delivered multi-tenant microservices on Docker and AWS EKS with Auth0 RBAC and caching optimizations.
WebRTC
WebSockets
LangChain
Milvus
FAISS
Redis
Celery
OpenAI
Groq
Gemini
Deepgram
ElevenLabs
Auth0
Docker
Kubernetes
Amazon EKS
RAG
Software Development Engineer Intern
•
Junior
ShortCode Technologies
•
Internship
Built real-time data pipelines capable of processing hundreds of events per second with sub-second latency using async I/O and performance-focused serialization. Improved an associated VR simulator data pipeline by reducing round-trip latency by about 20%, from roughly 200 ms to 160 ms.
Full Stack Developer Intern
•
Junior
Research Centre Imarat (RCI), DRDO
•
Internship
Developed a secure, high-availability intranet platform deployed across 60+ defense laboratories. Delivered an escalation and ticketing system designed for SLA-compliant resolution and later supported wider organizational adoption across DRDO.
Middle AI/ML Engineer
Confidence: High ML Engineer
An applied ML engineer focused on practical NLP inference and simple supervised models with a strength in building lightweight inference endpoints. The strongest proven skill is production inference engineering, demonstrated by the FastAPI detector that loads a transformers model, applies dynamic quantization and implements chunked inference and memory cleanup in main.py. There is limited evidence of rigorous experimentation, custom model development, CI/CD, monitoring or unit test coverage.
Model Architecture & Training
2/10
How well models are designed and trained
Basic use of off-the-shelf models and classical ML algorithms without custom architectures, advanced regularization or bespoke training loops.
Data Pipeline & Feature Engineering
2/10
How data is prepared for models
Simple data loading and preprocessing steps from spreadsheets and vectorization; no advanced augmentation, leakage controls or production ETL pipelines.
Experimentation & Evaluation
2/10
How results are measured and tested
Elementary experimentation and evaluation using train/test splits and classification_report; no experiment tracking, systematic validation or ablation runs.
MLOps & Deployment
4/10
How models are shipped to production
Practical deployment knowledge shown via a FastAPI inference service and Anvil uplink integration; startup loading, CORS handling and an HTTP endpoint are present but CI/CD, monitoring and model versioning are absent.
Computational Efficiency
4/10
How efficiently computing resources are used
Conscious efficiency work for inference including dynamic quantization, use of torch.inference_mode, chunked processing and explicit memory cleanup.
Research Depth & Innovation
1/10
Depth of research and new ideas
Little to no research depth or innovation; no custom layers, no reproduced paper implementations or controlled ablation studies.
Industries
Artificial Intelligence• Middle
Technologies
Python• since 2023 • Middle
SQL
C++
PostgreSQL
Redis• since 2025
LangChain• since 2025
llama.cpp
Milvus• since 2025
FAISS• since 2025
Groq• since 2025
GitHub Actions
OpenTelemetry
WebRTC• since 2025
Datadog
WebSockets• since 2025
ElevenLabs• since 2025
Embeddings• since 2026
Quantization
Scikit-learn
Prompt Engineering
AI Agents
NLP• since 2026
Llama
CI/CD
Transformers
Pandas
NumPy
PyTorch• since 2026
AWS• since 2026
Docker• since 2025
Kubernetes• since 2025
Cloudflare
Gemini• since 2025
LLM
RAG• since 2025
Whisper
Amazon EKS• since 2025
AWS Lambda
Amazon EC2
Tokenization
GAN• since 2026
CNN• since 2026
CUDA
OpenAI• since 2025
Hugging Face
GitHub
Amazon S3
Text-to-Speech
Deepgram• since 2025
Structured Outputs• since 2026
LLM Guardrails
Voice Agents
Linux
Machine Learning• since 2026
Recommendations
- Harden inference services with unit/integration tests, CI pipelines and basic observability (metrics, logs, health checks).
- Add experiment tracking and reproducible evaluation (W&B/MLflow configs, seed control, saved run metrics) for systematic model comparisons.
- Consolidate model packaging and deployment (containerization, model versioning, model artifacts) and add automated rollback/canary strategies.
- Expand into model optimization pipelines (quantization-aware training, QLoRA/pruning experiments) with before/after performance and accuracy measurements.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium API Engineer
A mid-level API-focused developer building lightweight ML inference services and web demos. The strongest proven skill is deploying an ML inference endpoint with practical memory and performance choices such as quantization, chunking, and per-chunk cleanup in backend-ai-detector/main.py. Production-ready concerns are not evidenced: there is no auth, no structured observability, no DB migrations, and CORS and secret handling are weak.
API Design
3/10
How well APIs are designed
API design is functional for an ML inference service but minimal; there is a single POST endpoint with form input and permissive CORS, no versioning, no structured error contract, and no idempotency/pagination design.
Evidence
backend-ai-detector/main.py: @app.post("/detect/text") endpoint implementation
backend-ai-detector/main.py: app.add_middleware(CORSMiddleware, allow_origins=["*"])
Data Layer & Database
1/10
Working with databases
There is basic data handling for ML (pandas/sklearn) and in-memory processing but no database, migrations, transaction handling, or tuned SQL; data-layer work is limited to file-based input and training scripts.
Evidence
house-prediction/webapp.py: df=pd.read_excel('/content/gdrive/MyDrive/test flies/test_data2.xlsx') and sklearn usage
Scalability & Performance
4/10
Handling load and speed
Several practical performance-minded decisions are present for model inference such as chunking, quantization, inference_mode, and explicit memory cleanup which indicate attention to resource constraints, but there is no end-to-end scaling design (no caching, queuing, or load-control).
Evidence
backend-ai-detector/main.py: model = torch.quantization.quantize_dynamic(...)
backend-ai-detector/main.py: chunk_text(...) and per-chunk gc.collect() / torch.cuda.empty_cache() usage
System Architecture
3/10
Overall system structure
A reasonable, simple architecture separates frontend and backend components and uses FastAPI startup events for model loading, but the system is a small monolith for inference without documented inter-service contracts or robust decomposition for production microservices.
Evidence
backend-ai-detector/main.py: @app.on_event("startup") async def load_model()
house-prediction/anvil_backend_linker.py: Anvil frontend integration calling backend uplink
Security & Auth
2/10
Protecting data and access
Security practices are weak to minimal: CORS is wide open, secrets are embedded in code (Anvil uplink key), and there is only basic input cleanup; there is no auth, token lifecycle, dependency audit, or hardened input validation.
Evidence
backend-ai-detector/main.py: app.add_middleware(CORSMiddleware, allow_origins=["*"])
house-prediction/webapp.py: anvil.server.connect("WDYT3MGMY72MUVUPP7EVS2PE-NCUWEQZGUHUCYTKI")
Reliability & Observability
3/10
Stability and monitoring
There are lightweight reliability measures for inference (try/except, memory cleanup, model.eval) and startup logs, but no structured logging, tracing/correlation ids, timeouts, retry/backoff policies, or metrics/alerts for production reliability.
Evidence
backend-ai-detector/main.py: try/except around detect_text and print statements in load_model
backend-ai-detector/main.py: model.eval() and gc.collect() usage
Expertise
Backend AI & LLM• Middle
Node.js• Junior
Industries
Artificial Intelligence• Middle
Real Estate• Middle
Technologies
Node JS• Middle
Rest API
FastAPI• since 2026
Celery• since 2025
Recommendations
- Develop and harden ML inference services ready for production: add auth, per-request timeouts, structured logging, metrics, and graceful startup/shutdown.
- Improve security hygiene by removing hardcoded secrets, using environment-backed secret management, and tightening CORS and input validation.
- Build a simple deployment pipeline for the model API with containerization and a lightweight queue or rate limiting to manage load during inference bursts.
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
Junior frontend UI engineer focused on building polished React page-level interfaces and visual layouts using Tailwind and framer-motion. The strongest proven skill is crafting attractive, responsive pages and simple detectors as shown in src/pages/Home.js and the detector pages (TextDetector.js, ImageDetector.js). There is little public evidence of advanced state management, production-grade backend integration patterns, extensive testing, or accessibility tooling in CI.
UI Component Architecture
3/10
How interface parts are built
Basic component structure and page-level composition using React functional components and simple separation into pages and small components; no evidence of a custom design system or advanced composition patterns.
Responsive & Cross-browser
3/10
Works on all screens and browsers
Responsive layout is achieved using Tailwind utility classes and basic responsive grid/breakpoints; no advanced feature detection, RTL or container queries shown.
Performance Optimization
1/10
Speed of the interface
No measured performance work or advanced optimizations; only basic use of framer-motion for animations and standard build scripts are present.
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility and semantics: basic semantic tags and form labels exist in templates and an image alt attribute is present, but no ARIA usage, focus management, keyboard support, or a11y tooling in CI.
State Management & Data Flow
2/10
Managing data in the app
Simple local state management with useState and basic error/loading handling for a fetch request; no advanced server-state discipline, cancellation, optimistic updates or state machines.
UX & Visual Polish
3/10
Look and feel quality
Good visual polish for a small project with animations, gradients and transitions and a visible loading state, but lacking skeletons, undo patterns or thorough edge-state UX.
Expertise
React• Junior
Frontend AI Integration• Junior
Industries
Data & Analytics• Junior
Health Care• Junior
Technologies
JavaScript• since 2025 • Junior
Tailwind CSS
React.js
PostCSS
React Router
autoprefixer
Recommendations
- Develop marketing and product-facing React pages and small feature UIs that prioritize visual polish and responsive layouts.
- Implement and connect simple frontend integrations to backend inference endpoints (lightweight AI/ML frontends) with improved error and loading handling.
- Build UI prototypes and single-feature applications where rapid iteration and UX polish matter, such as demos for model inference.
- Improve accessibility, add focused edge-state UX (skeletons, empty states), and add basic testing to raise reliability.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: