Kshitij Gera
Deployed Engineer
Python
TypeScript
C++
JavaScript
Node JS
C
Active 2 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
LLM-focused engineer (mid-level) who prototypes agentic workflows and LLM integrations rapidly; the strongest proven skill is building prototype autonomous agent flows using hosted model APIs as shown in Context-Manager/agent_v1.py and Context-Manager/multi_agent_system.py; public code does not show custom model training, evaluation pipelines, production-grade MLOps, or test coverage.
Phone
Technical skills
Languages
6
Python
TypeScript
C++
JavaScript
Node JS
C
Python
4
Requests
Django
FastAPI
Beautiful Soup
AI/ML
13
LLM
Triton
LiteLLM
Model Context Protocol
Google GenAI SDK
Claude
LangChain
LangGraph
PyTorch
TensorFlow
AI Agents
Claude Code
Cursor
Frontend
4
React.js
Next.js
Tailwind CSS
ESLint
DevOps
5
AWS
Azure
Kubernetes
Rest API
Docker
Other
13
PostgreSQL
Redis
TensorFlow C++
TensorRT
CI/CD
RAG
Fine-tuning
WebRTC
WebSockets
Human-in-the-Loop
Text-to-Speech
Voice Agents
Speech Recognition
Projects
Smart Irrigation System
Presented research on an IoT-based smart irrigation system at ECPC 2022. The work focused on using sensors and automation to support irrigation decision-making. The solution was demonstrated as a practical approach to smarter water management.
Handoff
Built Handoff, a shared context layer for AI coding agents that enables teams to attach, checkpoint, and search each other’s coding sessions. Implemented the coordination via MCP plugins so session context is reusable across different runners. The project uses a database-backed architecture and integrates with AI coding tools.
Timeline
Forward Deployed Engineer
•
Middle
Avoca AI
•
Full-Time
Built and maintained a human-in-the-loop platform supporting large-scale voice calls. Developed and deployed customer-specific features and onboarding flows, and configured production deployments and integrations. Deployed and monitored AI voice agents for multiple customers to ensure availability and fast issue resolution.
Software Engineer
•
Middle
Deep Cognition
•
Full-Time
Integrated LibreChat with multiple MCP servers and implemented an MCP routing layer for task-specific workflows. Reduced debugging and deployment turnaround by routing customer integrations more effectively. Added LiteLLM integration to centralize LLM telemetry such as latency, errors, and request tracing for production visibility.
Model Context Protocol
LiteLLM
AI Engineer
•
Middle
Miko AI
•
Full-Time
Developed a voice cloning service combining multiple voice-processing components and achieved high perceptual similarity across many voices. Built a speaker recognition pipeline with low-latency inference. Containerized and deployed the recognition and voice cloning models on Triton Inference Server with GPU-oriented optimizations for scalable throughput. Created ASR dataset generation workflows and evaluated TTS systems across multiple quality and efficiency metrics.
Triton
Indian Institute of Technology (IIT)
Bachelor's Degree
Intern
•
Junior
Flipkart
•
Full-Time
Built a computer-vision pipeline to detect pick points for a robotic pick-and-place workflow. Used image segmentation with a ResNet-based approach combined with depth data to compute 6-DoF grasp targets. Evaluated precision and inference speed to support real-time robotic decisions.
Middle AI/ML Engineer
Confidence: Medium LLM Engineer
LLM-focused engineer (mid-level) who prototypes agentic workflows and LLM integrations rapidly; the strongest proven skill is building prototype autonomous agent flows using hosted model APIs as shown in Context-Manager/agent_v1.py and Context-Manager/multi_agent_system.py; public code does not show custom model training, evaluation pipelines, production-grade MLOps, or test coverage.
Model Architecture & Training
1/10
How well models are designed and trained
Prototype-level LLM integration and agent orchestration using hosted model APIs; no custom model design or training code.
Evidence
Context-Manager/agent_v1.py: uses google.generativeai.GenerativeModel('gemini-2.5-flash') and constructs a JSON prompt to generate project files
Context-Manager/multi_agent_system.py: defines Agent instances and composes them with PraisonAIAgents to run a sequential Developer->Marketing->Sales pipeline
Data Pipeline & Feature Engineering
How data is prepared for models
Not evidenced in public code
Experimentation & Evaluation
How results are measured and tested
Not evidenced in public code
MLOps & Deployment
How models are shipped to production
Not evidenced in public code
Computational Efficiency
How efficiently computing resources are used
Not evidenced in public code
Research Depth & Innovation
Depth of research and new ideas
Not evidenced in public code
Expertise
AI Agents & Agentic Workflows• Middle
LLM• Middle
Technologies
Python• since 2025 • Middle
C++
PostgreSQL
Redis
Cursor
LangGraph
LangChain
Claude
Claude Code
Model Context Protocol• since 2025
WebRTC
WebSockets
Fine-tuning
Beautiful Soup
AI Agents
Speech Recognition
Google GenAI SDK
LiteLLM• since 2025
TensorRT
Azure
CI/CD
TensorFlow
PyTorch
AWS
Docker
Kubernetes
LLM• since 2024
RAG
TensorFlow C++
Requests
Triton• since 2024
Text-to-Speech
Human-in-the-Loop
Voice Agents
Claude• mentioned only
Recommendations
- Develop prototype agentic workflows and integrations with hosted LLMs and safe execution sandboxes where model outputs are validated before running system commands
- Build small internal tools that orchestrate LLM calls and browser automation with explicit error handling and audit logs
- Harden prototypes by adding testing, input validation, and safe execution wrappers around subprocess/git operations
- Work on MLOps glue for hosted-model-driven tooling such as session management, secrets-safe sharing (with scanning), and reproducible run metadata
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: Medium API Engineer
A pragmatic Middle-level backend API engineer specializing in Next.js server actions and Supabase-backed flows. The strongest proven skill is server-side form handling and Supabase data flows as implemented in app/goals/new/actions.ts and app/goals/[id]/actions.ts. There is limited evidence of database migrations, test coverage, explicit transactional handling, resilience patterns, or observability in public code.
API Design
3/10
How well APIs are designed
API surface is simple and consistent (server actions returning structured status objects) but lacks versioning, idempotency keys, pagination or a documented error contract beyond simple messages.
Evidence
Stake-gg/app/goals/[id]/actions.ts: joinGoal/submitProof/castVote return structured ActionState objects
Stake-gg/app/goals/new/actions.ts: createGoal implements server action form handling and redirects
Stake-gg/app/login/actions.ts: sendMagicLink validates input and returns typed SendMagicLinkState
Data Layer & Database
2/10
Working with databases
Uses Supabase client directly for selects and inserts with typed domain models, but there is no migration history, no explicit transactions or isolation handling, and potential multi-step operations are not wrapped atomically.
Evidence
Stake-gg/app/goals/new/actions.ts: inserts into goals then inserts into goal_participants in separate calls (no transaction)
Stake-gg/app/goals/[id]/actions.ts: reads goals and inserts into goal_participants using supabase.from
Stake-gg/lib/types.ts: typed domain models for goals, participants and proofs
Scalability & Performance
2/10
Handling load and speed
Minimal scalability work; uses Next.js revalidation primitives but no caching strategy, no queue-based decoupling or rate limiting and no measured performance optimizations.
Evidence
Stake-gg/app/goals/[id]/actions.ts: revalidatePath used after writes
Stake-gg/utils/supabase/middleware.ts: server client setup for SSR Supabase usage
System Architecture
3/10
Overall system structure
Code shows reasonable module boundaries (types, supabase middleware, server actions) and separation of concerns for auth and DB access, but overall architecture is small and monolithic without multi-service trade-offs or resilience boundaries.
Evidence
Stake-gg/utils/supabase/middleware.ts: central Supabase server client factory with cookie handling
Stake-gg/lib/types.ts: centralized domain type definitions
Stake-gg/app/*/actions.ts: server actions organized per feature route
Security & Auth
3/10
Protecting data and access
Authentication checks are present at server boundaries and basic input validation exists, but there is limited evidence of advanced auth lifecycle handling, secrets best-practices beyond env usage, or defense-in-depth against injection classes.
Evidence
Stake-gg/app/goals/[id]/actions.ts: checks supabase.auth.getUser() before performing DB writes
Stake-gg/app/login/actions.ts: input validation for email and uses signInWithOtp with origin-based redirect
Stake-gg/utils/supabase/middleware.ts: reads Next.js request cookies and wires them into Supabase client
Reliability & Observability
2/10
Stability and monitoring
Basic error handling and user-facing messages exist, but there is little observability or reliability engineering: no structured logging, no retries with backoff, no timeouts, and no test or monitoring artifacts.
Evidence
Stake-gg/app/goals/new/actions.ts: returns error messages from Supabase to the caller
Stake-gg/app/goals/[id]/actions.ts: checks for missing user and DB errors and returns ActionState
Expertise
Node.js• Junior
Technologies
Node JS• Junior
Rest API
FastAPI
Django
Recommendations
- Implement transactional consistency for multi-step DB changes (or document and use DB-side transactions) and add migration history for schema evolution.
- Add automated tests (unit and integration) around server actions and database interactions to prevent regressions.
- Introduce observability: structured logs, request correlation ids, metrics and basic health checks; add retry/backoff patterns where external calls can fail.
- Document API error contracts and consider idempotency keys or checks for operations that may be retried by clients.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium App Engineer
App engineer (Middle) focused on Next.js server actions and server-driven form/workflow handling. The strongest proven skill is building server-side data flows and authentication-backed mutations as shown in app/goals/new/actions.ts and utils/supabase/middleware.ts. There is little or no public evidence of custom UI component systems, accessibility work, automated tests, or measured performance tuning.
UI Component Architecture
2/10
How interface parts are built
Minimal component architecture; server-side actions and domain types separate concerns but there is no evidence of a custom component library, composition patterns, or complex UI architecture.
Evidence
Stake-gg/lib/types.ts: domain types for goals, participants, proofs and votes
Stake-gg/app/goals/new/actions.ts: server action that validates form input and creates goal and participant records
Responsive & Cross-browser
Works on all screens and browsers
Not evidenced in public code
Performance Optimization
2/10
Speed of the interface
Small, pragmatic performance-aware choices in server middleware and cache invalidation are present, but no measured optimizations, bundle analysis or advanced client-side performance patterns.
Evidence
Stake-gg/utils/supabase/middleware.ts: custom createServerClient wrapper that synchronizes cookies with NextResponse
Stake-gg/app/goals/[id]/actions.ts: uses revalidatePath to update cached pages after mutations
Accessibility & Semantics
Usable for everyone
Not evidenced in public code
State Management & Data Flow
3/10
Managing data in the app
Server-state and data-flow discipline is evident through Next.js server actions and Supabase usage with input validation and explicit error handling, but there are no advanced client-side state techniques like optimistic updates with rollback, request cancellation, or state machines.
Evidence
Stake-gg/app/goals/new/actions.ts: createGoal validates inputs, inserts goal and a participant, and redirects on success
Stake-gg/app/goals/[id]/actions.ts: joinGoal reads authenticated user, queries the goal, inserts participant and returns structured ActionState on errors
UX & Visual Polish
2/10
Look and feel quality
Basic UX considerations exist in the form of structured action result types and user-facing error messages, but there is no evidence of skeletons, undo patterns, or sophisticated perceived-performance techniques.
Evidence
Stake-gg/app/login/actions.ts: sendMagicLink returns explicit status messages for the UI
Stake-gg/app/goals/[id]/actions.ts: ActionState type and returned error messages for client consumption
Expertise
React• Junior
Modern Web Frameworks• Junior
Technologies
JavaScript
TypeScript• since 2025 • Junior
Tailwind CSS
Next.js
React.js
ESLint
Recommendations
- Build Next.js apps with Supabase-backed server actions and authenticated form workflows.
- Implement medium-complexity B2B features such as goal/workflow CRUD, proof submissions, and voting with server-side validation and cache invalidation.
- Harden and expand backend-for-frontend logic (middleware, cookie handling, secure server clients) and add end-to-end tests and CI for reliability.
- Improve frontend evidence by extracting UI components, adding a11y checks, and introducing client-side optimistic updates where appropriate.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: