Madhan Jagannadham
AI Engineer
Rust
Solidity
JavaScript
Node JS
TypeScript
Python
SQL
Experimentation & Evaluation: 5/10
MLOps & Deployment: 5/10
Data Pipeline & Feature Engineering: 4/10
Active 2 days ago
+91 (8328) 557699 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
LLM engineer-level developer (senior) focused on building production-ready agent systems and LLM-powered backends. The strongest proven skill is architecting agent orchestration and tool-RAG with isolation and composable tools, evidenced by Repomind's orchestrator (src/repomind/agent/orchestrator.py) and the tool registry/init process (src/repomind/tools/init_tools.py). Public code does not show custom model training, novel architectures, or low-level GPU/quantization optimization work.
Technical skills
Rust
Solidity
JavaScript
Node JS
TypeScript
Python• Senior
SQL• Junior
Python
Flask
Pydantic
Uvicorn
FastAPI
Databases
MySQL
SQLite
pgvector
Redis
PostgreSQL
Google BigQuery
AI/ML
AI Agents
NumPy
Pandas
PyTorch
Transfer Learning
XGBoost
Google GenAI SDK
Embeddings
FastEmbed
LangChain
LangGraph
LLM
OpenCV
RAG
Scikit-learn
TensorFlow
Computer Vision
NLP
Vertex AI
Gemini
Frontend
React.js
Vite
Tailwind CSS
DevOps
AWS
Azure
Docker
GCP
Git
Rest API
CI/CD
Web3
Ethereum
Polygon
Smart Contracts
Zk-Proofs
DeFi
Solana
Mobile
Firebase
Timeline
Generative AI & Full Stack Developer Intern
•
Junior
Hrtek System
•
Internship
Built LLM-based AI agents and RAG pipelines to automate HRIS/HCMS workflows such as onboarding, policy Q&A, and HR service automation. Worked on fine-tuning LLMs using proprietary HR data to generate job descriptions, interview questions, and performance review templates. Supported end-to-end feature enhancements and implementation for the HR technology product ecosystem.
LangChain
LangGraph
LLM
RAG
Summer Research Intern
•
Junior
Maulana Azad National Institute of Technology (MANIT)
•
Internship
Developed and deployed an AI-assisted facial authenticity verification system achieving high accuracy. Engineered multiple image features and compared several ML and DL architectures. Implemented a ResNet50 transfer learning approach using TensorFlow, OpenCV, and scikit-learn for improved performance.
TensorFlow
OpenCV
Scikit-learn
Senior AI/ML Engineer
Confidence: High LLM Engineer
LLM engineer-level developer (senior) focused on building production-ready agent systems and LLM-powered backends. The strongest proven skill is architecting agent orchestration and tool-RAG with isolation and composable tools, evidenced by Repomind's orchestrator (src/repomind/agent/orchestrator.py) and the tool registry/init process (src/repomind/tools/init_tools.py). Public code does not show custom model training, novel architectures, or low-level GPU/quantization optimization work.
Model Architecture & Training
1/10
How well models are designed and trained
No custom model architectures or training loops are present; interactions are SDK-driven schema-constrained calls to hosted models rather than model-building work.
Evidence
note_insight/backend/app/gemini_service.py: run_analysis uses google.genai.Client with response_schema=AIAnalysisOutput to validate model output
parcel_pilot/backend/app/agent/orchestrator.py: plan/execute use Groq client for LLM-driven orchestration rather than training or fine-tuning
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Clear, pragmatic data ingress and transformation code with chunking, ingestion, embedding calls, and careful Firestore denormalization; however this is application-level ETL rather than advanced feature engineering for model training.
Evidence
parcel_pilot/backend/app/ingest/chunking.py: chunk_document and sliding-window chunking utilities
parcel_pilot/backend/app/ingest/load_documents.py: _extract_text and load_documents pipeline calling embed and chunk_document
note_insight/backend/app/firestore_service.py: compute_review_metrics and denormalized note fields for efficient listing
Experimentation & Evaluation
5/10
How results are measured and tested
Honest evaluation and automation infrastructure is present: an eval harness, scripted cases, integrated LLM judges, and extensive unit/integration tests demonstrating reproducible evaluation practices.
Evidence
Repomind/eval/harness.py: EvalHarness to run and score orchestrator on target repos
parcel_pilot/backend/scripts/eval.py: repeatable cases, keyword pre-filter and LLM judge (grade_answer)
Repomind/tests/integration/test_orchestrator_e2e.py: integration tests asserting tool-RAG and subagent isolation
MLOps & Deployment
5/10
How models are shipped to production
Good production-minded scaffolding: FastAPI apps, streaming endpoints, caching, structured error handling, observability and retry/rate-limiting utilities support deployable LLM systems and guarded external calls.
Evidence
note_insight/backend/app/routers/notes.py: FastAPI streaming and fallback behavior with schema validation and persistent failed-analysis records
Repomind/src/repomind/observability.py and src/repomind/resilience.py: structured logging, tracing decorators, tenacity-based retry patterns and a RateLimiter
note_insight/backend/app/gemini_service.py: in-process caching (_analysis_cache) and explicit API-key handling in _get_client
Computational Efficiency
3/10
How efficiently computing resources are used
Some practical efficiency choices (in-memory result caching, embedding over-fetch then filter, limited streaming), but no low-level GPU, quantization, or distributed training/serving optimizations.
Evidence
note_insight/backend/app/gemini_service.py: get_cached_analysis/_store_cache avoids duplicate API calls for identical inputs
parcel_pilot/backend/app/tools/read_tools.py: doc_search over-fetches embeddings then scope-filters results to reduce RAG errors
Research Depth & Innovation
4/10
Depth of research and new ideas
Strong applied engineering and design of agent orchestration and tool-RAG with subagent isolation, but not academic research or novel model algorithms; innovation is in system design and composition.
Evidence
Repomind/src/repomind/agent/orchestrator.py: five-node orchestrator with tool-RAG, subagent delegation and context compaction
Repomind/src/repomind/tools/init_tools.py: idempotent registry bootstrapping of many composable tools (tooling-first architecture)
Expertise
AI Agents & Agentic Workflows• Senior
RAG• Middle
MLOps & Model Lifecycle• Middle
Industries
Health Care• Middle
Transportation & Logistics• Middle
Technologies
Python• Senior
SQL• Junior
MySQL
PostgreSQL
LangGraph
Rest API
LangChain
pgvector
Flask
OpenCV
XGBoost
FastAPI
Embeddings
Scikit-learn
Computer Vision
AI Agents
NLP
Transfer Learning
FastEmbed
Google GenAI SDK
Azure
TensorFlow
Pandas
NumPy
Git
SQLite
PyTorch
AWS
Docker
LLM
RAG
Pydantic
Recommendations
- Build and extend agentic LLM systems that require tool-RAG, scoped tool registries, and subagent isolation (example: autonomous code-audit or multi-step automation).
- Implement production LLM-backed APIs with robust streaming, retry, and fallback behavior (FastAPI streaming endpoints and gemini_service patterns are a fit).
- Design evaluation harnesses and grading pipelines that combine keyword checks and LLM judges for repeatable system-level benchmarks (scripts/eval.py and Repomind eval harness).
- Integrate embedding-backed retrieval and document ingestion pipelines for retrieval-augmented apps, leveraging pgvector or fastembed and carefully scoped access control.
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
Backend engineer (senior) focused on building robust API services that integrate LLMs and external systems with an emphasis on correctness and safety. The strongest proven skill is designing dependable LLM integration and validation pipelines as evidenced by gemini_service.py and the accompanying tests that cover retries, streaming, schema validation, and quote verification. Public code does not show large-scale multi-instance production ops (distributed caching, service mesh, or long-running deployment/observability configuration) nor low-level DB migration history for schema evolution.
API Design
6/10
How well APIs are designed
API design shows deliberate route-level error mapping, streaming SSE support, rate-limit enforcement, and integration tests exercising HTTP semantics and auth; good use of Pydantic for request/response shapes and explicit handling of failure modes.
Evidence
JMadhan1/note_insight/backend/tests/test_notes_router.py: integration tests asserting 401/429/422/502 behaviors and SSE delta/complete/error events
JMadhan1/parcel_pilot/backend/app/api/routes.py: orchestrator-driven endpoints and streaming endpoint signatures (human-authored routing and error handling)
Data Layer & Database
6/10
Working with databases
Data layer shows conscious denormalization to avoid N+1 reads, scoped per-user Firestore paths, and explicit SQL queries with parameterization and pgvector usage; migration history is not visible but query/index tradeoffs are considered in code comments.
Evidence
JMadhan1/note_insight/backend/app/firestore_service.py: denormalized latestConditionCount/latestReviewStatus to avoid per-row N+1 reads and user-scoped users/{uid}/notes/{noteId} layout
JMadhan1/parcel_pilot/backend/app/tools/read_tools.py: hand-written SQL queries with parameter binding and pgvector similarity expression in doc_search
Scalability & Performance
5/10
Handling load and speed
Performance-conscious patterns appear (local in-process caching for identical AI calls, over-fetch+filter strategy for vector search, and a simple rate limiter), but there is no evidence of system-wide distributed caching, benchmarking, or sophisticated connection-pooling configuration.
Evidence
JMadhan1/note_insight/backend/app/gemini_service.py: in-process _analysis_cache to avoid repeat Gemini calls
JMadhan1/note_insight/backend/app/rate_limit.py: request-window limiter with tests verifying enforcement
JMadhan1/parcel_pilot/backend/app/tools/read_tools.py: SQL over-fetch then scope-filter strategy for relevance + access control
System Architecture
6/10
Overall system structure
Clear separation of concerns across modules (LLM client, DB service, auth, tool registry), an explicit propose-then-confirm pattern for actions, and an LLM tool registry/orchestrator indicate deliberate architecture and thoughtful trade-offs.
Evidence
JMadhan1/parcel_pilot/backend/app/tools/registry.py: tool registration and schema-driven handlers
JMadhan1/parcel_pilot/backend/app/tools/action_tools.py: separation of proposal (PENDING) from execution and explicit confirmation gate
JMadhan1/parcel_pilot/backend/scripts/eval.py: orchestrated, repeatable evaluation harness demonstrating system-level testing and orchestration
Security & Auth
6/10
Protecting data and access
Security-aware choices include strict uid-scoped Firestore paths to prevent cross-user data leakage, parameterized SQL queries, rate limiting, and tests asserting auth/enforcement; token lifecycle and revocation mechanics are not visible in depth.
Evidence
Reliability & Observability
6/10
Stability and monitoring
Reliability patterns are present: retries and schema validation around external LLM calls, streaming fallback behavior, explicit fail-analysis persistence, and test coverage of failure paths and idempotency; observability/metrics hooks are lightweight (log messages) rather than full SLI instrumentation.
Evidence
JMadhan1/note_insight/backend/app/gemini_service.py: retry loop in run_analysis, AnalysisFailure handling, and logging on failures
JMadhan1/note_insight/backend/tests/test_gemini_service.py: tests covering retry, fallback, stream handling, and verification behavior
JMadhan1/parcel_pilot/backend/app/tools/action_tools.py and backend/tests/test_access_control.py: confirm_action and tests preventing double-confirm/execution
Expertise
Backend AI & LLM• Senior
Databases & Vector Storage• Senior
Microservices & API Architecture• Senior
Python• Senior
Industries
Health Care• Senior
Transportation & Logistics• Senior
Government• Senior
Technologies
Redis
GCP
Uvicorn
Recommendations
- Develop production-grade API services that integrate LLMs with strict validation, streaming UX (SSE) and safety fallbacks.
- Implement vector-search backed features and embeddings-first data products that need pgvector and tight SQL integration.
- Build secure, audited tooling around identity and cryptographic proofs where correctness and careful validation matter.
- Own backend features requiring careful access-control, propose-then-confirm action patterns, and thorough HTTP-level integration tests.
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
Frontend app engineer at a Middle level specializing in blockchain-integrated client-side tooling and deployment utilities. The strongest proven skill is building lightweight integration layers and async RPC wrappers, demonstrated by initVault and the getScore/getLeaderboard API surface in varavault/web/src/vault.js. The public code does not show a component-system architecture, broad a11y work, end-to-end test coverage, or measured performance optimization results.
UI Component Architecture
2/10
How interface parts are built
Minimal component architecture evidence; the human-authored code is primarily utility modules and global CSS rather than a deliberate React/component system or design-system with composable primitives.
Evidence
varavault/web/src/vault.js: initVault() and small exported API functions used by the UI rather than component definitions
varavault/web/src/index.css: global styling and utility classes instead of component-scoped CSS modules or a custom component library
Responsive & Cross-browser
5/10
Works on all screens and browsers
Conscious responsive and cross-browser choices are present - logical color-scheme handling, select option fallbacks and media queries show attention to cross-browser UX and responsive layouts.
Evidence
varavault/web/src/index.css: color-scheme declarations and select option rules to avoid light popup list issues
varavault/web/src/index.css: responsive media queries for layout and prefers-reduced-motion support
Performance Optimization
2/10
Speed of the interface
Limited performance engineering artifacts; there is some client-side memoization and reduced-motion respect, but no measured optimizations, bundle analysis, or advanced runtime techniques.
Evidence
varavault/web/src/vault.js: initVault() lazy memoization to avoid repeated API initialisation
varavault/web/src/index.css: prefers-reduced-motion media query indicating some runtime animation control
Accessibility & Semantics
3/10
Usable for everyone
Basic accessibility and semantics practices are present such as color-scheme and reduced-motion, but there is no evidence of ARIA on custom widgets, focus management, keyboard navigation, or a11y automation in CI.
Evidence
varavault/web/src/index.css: color-scheme and explicit select option styling to ensure readable native controls
varavault/web/src/index.css: @media (prefers-reduced-motion: reduce) block
State Management & Data Flow
4/10
Managing data in the app
Good async discipline for a small integration layer - lazy singleton initialization, clear RPC wrapper functions and defensive error handling for network queries; however no advanced race cancellation, optimistic-updates or state machines are present.
Evidence
varavault/web/src/vault.js: initVault() provides a memoized client and sails parser pattern
varavault/web/src/vault.js: getLeaderboard() and getScore() use try/catch and skip individual failures to keep the UI resilient
UX & Visual Polish
5/10
Look and feel quality
High visual polish at the CSS level with theming tokens, animations and utility tokens for tier colors and glows; good UX attention though much of it is stylistic rather than evidence of complex interactive UX flows.
Evidence
varavault/web/src/index.css: theme variables, animation keyframes, glow and pulse styles
varavault/web/src/index.css: tokenized color classes for tiers and utility classes like .glow and .pulse-ring
Expertise
React• Junior
Frontend Architecture & Build Tools• Junior
Industries
Blockchain & Crypto• Junior
Technologies
JavaScript
TypeScript
Node JS
Tailwind CSS
React.js
Vite
Recommendations
- Develop wallet-integrated read-only dApp frontends and dashboards that query chain data and map program state to UI components.
- Implement deployment and release automation for blockchain programs and developer tooling around program uploads and event tracing.
- Build client SDKs and small integration layers that encapsulate RPCs and program IDLs similar to the existing initVault pattern.