Suvom Karak
Suvom Karak

Suvom Karak

Backend • Senior • 27 years • Phoenix, USA • UTC-07:00 • Relocation • Work permits: United States, India • Available in 4 weeks
AI Engineer
5+ years exp
SQL
JavaScript
Node JS
Python
TypeScript
System Architecture: 5/10
API Design: 4/10
Data Layer & Database: 4/10
Active 7 days ago
+91 (8777) 061431
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles

Overview

A Senior-level backend API engineer focused on building LLM-backed document ingestion and templating pipelines for legal and education scenarios. The strongest proven skill is designing a modular LLM + embedding pipeline and template-matching flow implemented across services/template_matcher.py, services/gemini_service.py and services/embedding_service.py. There is limited evidence of production-grade CI/CD, structured observability (traces/metrics/alerts) and formal schema migration history in the public code.

Technical skills

SQL
JavaScript
Node JS• Senior
Python• Senior
TypeScript• Middle
Python
SQLAlchemy
FastAPI• 5y+
Flask• 5y+
Pydantic
Databases
ElasticSearch
SQLite
DynamoDB
OpenSearch
PostgreSQL
Frontend
Next.js
React.js
Tailwind CSS
Framer Motion
autoprefixer
React Hook Form
DevOps
AWS
CI/CD
Docker
GCP
Vector
Vercel
WebSockets
Rest API
Azure• 5y+
AWS Lambda
Git
OpenTelemetry
AI/ML
AWS Bedrock
Claude
Claude Code
Cursor
Gemini
Google ADK
Hybrid Search
LangChain
LangSmith
RAG
Semantic Search
Vertex AI
Guardrails AI
Langfuse
LangGraph
LLM

Timeline

Senior AI Engineer • Senior
Deloitte US • Full-Time
Dec 2024 to Present 1 Year 8 Months In office
Architected a reusable multi-agent platform using a FastAPI agentic gateway with session identity, graph lifecycle, streaming, and durable state persistence. Built an LLM supervisor/orchestrator with LangGraph, including structured output classification, follow-up-aware routing, and tool-based agent handoffs with policy-gated data access and self-correction. Implemented multi-mode human-in-the-loop controls using LangGraph interrupt/resume with PostgreSQL checkpointing, plus end-to-end guardrails and continuous evaluation/observability instrumentation.
LangGraph
FastAPI
Pydantic
PostgreSQL
Langfuse
OpenTelemetry
OpenSearch
Guardrails AI
AWS Lambda
DynamoDB
AI Engineer • Middle
Tata Consultancy Services • Full-Time
Jul 2021 to Nov 2024 3 Years 4 Months In office
Developed production LLM applications on Azure OpenAI for enterprise document processing and semantic search across knowledge bases. Built RAG and semantic-search pipelines using vector databases and Azure Cognitive Search, including automated key information extraction, chunking, and categorization. Implemented backend services for AI document analysis and real-time multilingual text processing with vision-based extraction using Flask/FastAPI, and integrated natural-language access to enterprise tools under enhanced security controls.
Azure
FastAPIsince 2021
Flask
Techno India University
Bachelor's Degree • Electrical Engineering
2017–2021 Kolkata, West Bengal
Senior Backend Developer Confidence: Medium API Engineer
A Senior-level backend API engineer focused on building LLM-backed document ingestion and templating pipelines for legal and education scenarios. The strongest proven skill is designing a modular LLM + embedding pipeline and template-matching flow implemented across services/template_matcher.py, services/gemini_service.py and services/embedding_service.py. There is limited evidence of production-grade CI/CD, structured observability (traces/metrics/alerts) and formal schema migration history in the public code.
API Design
4/10
How well APIs are designed
Reasonable API design with clear REST endpoints, response models, streaming support and input validation but no formal versioning, idempotency keys, or pagination strategy documented.
Evidence
Legal-Docs-AI/backend/main.py: multiple FastAPI endpoints with response_model and validate_request_size middleware
Reader-AI/app/api/chat-pdf/route.ts: builds system prompt and streams Groq chat completions to client
Data Layer & Database
4/10
Working with databases
Solid data-layer usage with SQLAlchemy ORM and transactional commit/rollback patterns, but no migration history or explicit schema evolution scripts are present.
Evidence
Legal-Docs-AI/backend/database.py: SQLAlchemy models and sessionmaker usage
Legal-Docs-AI/backend/main.py: save_template uses db.flush(), db.commit(), and db.rollback() on error
Scalability & Performance
4/10
Handling load and speed
Several practical scalability choices are present (text chunking, batch upserts, namespace isolation, exponential backoff), but no end-to-end capacity planning, caching invalidation strategy, or load-test artifacts.
Evidence
Reader-AI/app/api/process-pdf/route.ts: chunkText implementation, batching upserts to Pinecone and namespace isolation
Legal-Docs-AI/backend/services/exa_service.py: retry logic with exponential backoff for exa_api calls
System Architecture
5/10
Overall system structure
Deliberate modular architecture separating LLM wrappers, embedding logic, template extraction, matching and web bootstrap services, showing thoughtful decomposition for LLM-backed features.
Evidence
Legal-Docs-AI/backend/services/template_matcher.py and services/template_extractor.py: separate matching and extraction responsibilities
Legal-Docs-AI/backend/services/gemini_service.py and embedding_service.py: dedicated LLM and embedding service wrappers
Security & Auth
3/10
Protecting data and access
Basic input validation and environment checks exist, but there is limited evidence of comprehensive auth, secret management, token lifecycle, or formal threat mitigations like SSRF/SQLi hardened patterns.
Evidence
Legal-Docs-AI/backend/main.py: validate_request_size middleware and file size checks in upload endpoint
Legal-Docs-AI/backend/config.py: dotenv loading and settings checks
Reliability & Observability
4/10
Stability and monitoring
Good reliability practices in places: startup health checks, retry/backoff logic, streaming guards and debug traces; lacking are structured tracing/correlation ids, formal metrics or alerting config.
Evidence
Legal-Docs-AI/backend/services/gemini_service.py: _generate_json_response implements retries and exponential backoff
Legal-Docs-AI/backend/main.py: lifespan startup checks and health endpoint plus debug logging
Expertise
Backend AI & LLM• Senior
Databases & Vector Storage• Middle
Microservices & API Architecture• Senior
Python• Middle
Node.js• Middle
Industries
Professional Services• Senior
Education• Middle
Technologies
Python• Senior
Node JS• Senior
SQLAlchemy
FastAPI• 5y+
SQLite
Recommendations
  • Build LLM-backed document ingestion and RAG microservices that scale - focus on improving batching, rate-limit handling, and safe namespace management for multi-tenant Pinecone usage.
  • Harden production readiness by adding structured logging, distributed tracing, metrics and alerting, plus CI/CD pipelines and deployment manifests.
  • Implement secure secret management and auth (API tokens, scopes, refresh/revocation) and add input sanitization and safe deletion guards around destructive vector ops.
  • Develop a migration history (alembic or similar) and add automated integration tests around DB transactions, template extraction and LLM fallbacks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Reader-AI Legal-Docs-AI AI-Training-Simulation
Middle Frontend Developer Confidence: Medium Fullstack
Fullstack developer (mid-level) focused on building LLM-powered web features and integrations with a strength in designing server-side LLM orchestration and state checkpointing. The strongest proven skill is LLM integration and conversational state management as shown by the ChatGraph, KvCheckpointer, provider abstraction and the Next.js API routes that implement streaming, reranking and vector-index workflows. There is limited evidence of automated testing, formal a11y work, measured performance tuning, or a large bespoke component design system in public code.
UI Component Architecture
3/10
How interface parts are built
Some deliberate component work (custom toast hook and global theme tokens) shows component thinking and small, reusable patterns but no evidence of a broad, original design system or advanced component architecture.
Evidence
Reader-AI/components/ui/use-toast.ts: custom toast hook and reducer implementation
Legal-Docs-AI/frontend/components/ui/use-toast.ts: parallel custom toast hook implementation
Legal-Docs-AI/frontend/app/globals.css: custom CSS variables and theme tokens
Responsive & Cross-browser
2/10
Works on all screens and browsers
Uses Tailwind and global CSS tokens for theming; lacks evidence of advanced responsive strategies (container queries, feature detection, RTL readiness) or explicit cross-browser fallbacks.
Evidence
Reader-AI/tailwind.config.ts: Tailwind config present
Legal-Docs-AI/frontend/styles/globals.css: theme tokens and base styles
Performance Optimization
3/10
Speed of the interface
Practical runtime optimizations are present (text chunking with overlap, batching upserts, streaming LLM responses, rerank fallbacks) but there are no measured before/after performance artifacts, bundle analysis, or advanced client-side optimization patterns.
Evidence
Reader-AI/app/api/process-pdf/route.ts: chunkText with overlap and batched upserts to Pinecone
Reader-AI/app/api/chat-pdf/route.ts: streaming Groq completions and Cohere rerank fallback
AI-Training-Simulation/lib/llm/providers.ts: models configured with streaming enabled
Accessibility & Semantics
1/10
Usable for everyone
Minimal explicit accessibility work; typography and theme tokens exist but there is little to no evidence of keyboard/focus management, ARIA on custom widgets, or CI a11y checks.
Evidence
Reader-AI/components/ui/use-toast.ts: custom UI hook exists but no keyboard/focus handling
Legal-Docs-AI/frontend/styles/globals.css: global styles and tokens without explicit a11y utilities
State Management & Data Flow
4/10
Managing data in the app
Solid server-state and data-flow patterns for LLM interactions: environment validation, provider abstraction, conversational state checkpointing and a graph/invocation pattern that saves conversation state; this shows deliberate design for LLM orchestration and error handling.
Evidence
AI-Training-Simulation/lib/graph/createGraph.ts: ChatGraph merges messages and saves conversation state
AI-Training-Simulation/lib/config/env.ts: loadEnv with provider-specific validation
AI-Training-Simulation/lib/llm/providers.ts: abstraction over OpenAI/Anthropic/Google provider creation
UX & Visual Polish
4/10
Look and feel quality
Polished visual system and UX attention: global design tokens, dark mode variants, animation utilities and custom toast behavior indicate good visual polish and attention to perceived performance, although some parts appear scaffolded from templates.
Evidence
Legal-Docs-AI/frontend/app/globals.css: detailed design tokens, dark theme, animations and layout utilities
AI-Training-Simulation/src/index.css: custom animations and UX-focused styles
Reader-AI/components/ui/use-toast.ts: custom toast lifecycle and UX interactions
Expertise
Frontend AI Integration• Middle
React• Middle
Modern Web Frameworks• Middle
Industries
Education• Middle
Professional Services• Middle
Technologies
JavaScript
TypeScript• Middle
Tailwind CSS
Next.js
Vercel
React.js
Framer Motion
React Hook Form
autoprefixer
Recommendations
  • Lead development of Next.js fullstack features that integrate LLMs, RAG and vector search (query embedding, reranking, streaming responses).
  • Implement and harden conversational state and checkpointing for production LLM services, including retry/backoff, request cancellation and observability hooks.
  • Build small-to-medium LLM-powered UX features (PDF assistants, document templating, image-to-text explainers) and own end-to-end deployment on Vercel or similar platforms.
  • Consolidate a component design system and add a11y and testing (axe, CI linting, and snapshot/unit tests) to raise frontend architecture maturity.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Reader-AI Legal-Docs-AI AI-Training-Simulation
Middle Game Developer Confidence: Medium Generalist
Full-stack AI web engineer (middle level) focusing on LLM-backed document and chat pipelines with practical system integrations. The strongest proven skill is building server-side RAG and assistant pipelines as evidenced by Reader-AI/app/api/process-pdf/route.ts and AI-Training-Simulation/lib/graph/createGraph.ts. There is little or no public evidence of game-engine, graphics/shader, deterministic simulation, netcode, or systematic performance profiling work.
Gameplay Systems & Mechanics
How game logic works
Not evidenced in public code
Graphics & Rendering
Drawing game visuals
Not evidenced in public code
Physics & Math
Game physics and math
Not evidenced in public code
Engine Proficiency
3/10
Skill with the game engine
Shows practical engine/framework proficiency for web/ML backends: clear separation of concerns, LLM provider factory, chat graph state management, and reusable client/hooks beyond default templates.
Evidence
AI-Training-Simulation/lib/llm/providers.ts: createChatModel provider factory for OpenAI/Anthropic/Google
AI-Training-Simulation/lib/graph/createGraph.ts: ChatGraph class that merges history, invokes model, and persists state
Legal-Docs-AI/frontend/lib/api.ts: ApiClient wrapper encapsulating HTTP/JSON error handling for backend endpoints
Performance & Frame Budget
2/10
Keeping the game smooth
Some attention to runtime costs (text chunking with overlap, batched upserts, streaming responses) but no measured profiling, zero-allocation hot-paths, or documented frame-budget / latency targets.
Evidence
Reader-AI/app/api/process-pdf/route.ts: chunkText with overlap and batching upsert every 10 vectors
Reader-AI/app/api/chat-pdf/route.ts: uses large topK and Cohere rerank fallback; streams model responses
Content Pipeline & Tooling
3/10
Tools for game content
Concrete content pipelines and tooling for document ingestion, template extraction and LLM-based drafting are present, including client wrappers and sample output documentation.
Evidence
Legal-Docs-AI/backend/README.md: documented backend setup and APIs for templating
Legal-Docs-AI/sample_outputs/README.md: describes generated template outputs and front-matter
Legal-Docs-AI/frontend/lib/api.ts: ApiClient methods for upload/extract/save/template workflows
Industries
Education• Middle
Software• Middle
Recommendations
  • Lead development of LLM-backed document and assistant features - ingestion, embedding, vector DB upsert and RAG pipelines.
  • Build and harden stateful chat services and provider abstractions (LLM provider factory, streaming handlers, checkpointer integration).
  • Add production-grade observability and performance work: profiler captures, latency budgets, and zero-alloc hot-path improvements for embedding/upsert flows.
  • Develop full-stack SaaS prototypes that integrate backend AI services, client SDKs, and export formats (DOCX/Markdown) where existing ApiClient and template logic can be extended.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Reader-AI Legal-Docs-AI AI-Training-Simulation