Karuna Yadav
Software Developer
Management: Under a year (1-5 people)
Python
JavaScript
TypeScript
Node JS
SQL
API Design: 6/10
Data Layer & Database: 6/10
Scalability & Performance: 6/10
Active 10 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A Senior-level backend API engineer focused on building LLM-backed agentic systems and search/scraping backends with resilience and guardrails. The strongest proven skill is architecting agent/tool integrations and resilient backend tooling as shown by the agent node graph and MCP tool registry (Accommodation_Discovery_Agent/src/agent/graph.py and src/mcp/registry.py). Public code does not show large-scale production orchestration like k8s-based deployments, multi-region scaling, or formal security audits and secret-rotation pipelines.
Phone
Technical skills
Languages
5
Python
JavaScript
TypeScript
Node JS
SQL
Python
5
FastAPI
Pydantic
Boto3
HTTPX
structlog
DevOps
7
GitHub
Git
Kubernetes
Docker
CI/CD
AWS
Azure
Databases
4
Redis
Apache Kafka
PostgreSQL
ElasticSearch
Frontend
4
React.js
Next.js
Tailwind CSS
Zod
AI/ML
3
LLM
LangGraph
LangChain
Other
15
Playwright
Ioredis
Vitest
OpenTelemetry
Neo4j
pgvector
TanStack Virtual
Prisma
GitHub Actions
Databricks
Spark
Uvicorn
Rest API
Langfuse
SigNoz
Timeline
Software Engineer
•
Middle
Celebal Technologies
•
Full-Time
Built a customer data platform backend and distributed systems with Python and FastAPI. Reduced Databricks infrastructure costs by identifying repeated analytical workloads and introducing a Redis caching layer to avoid unnecessary compute. Reworked ingestion and metadata handling into Kafka-based asynchronous processing and added timeouts, retries, and explicit state transitions to prevent silent failures. Implemented PostgreSQL-backed workflows and improved production debugging with structured logging and failure-path tracing, supporting Docker, Kubernetes, and CI/CD validation.
Python
FastAPI
PostgreSQL
Redis
Apache Kafka
Docker
Kubernetes
CI/CD
Rajiv Gandhi Proudyogiki Vishwavidyalaya (Rajiv Gandhi Technical University)
Bachelor's Degree •
Computer Science Engineering
Junior Associate Trainee
•
Junior
Celebal Technologies
•
Full-Time
Developed backend and data workflows using Python, FastAPI, PostgreSQL, and REST APIs. Contributed to reusable validation and service logic, supported API integrations, and participated in testing, debugging, and code reviews. Delivered code via Git-based workflows and worked on integration tasks across backend components for the platform.
Python
FastAPI
PostgreSQL
Middle Backend Developer
Confidence: High API Engineer
A Senior-level backend API engineer focused on building LLM-backed agentic systems and search/scraping backends with resilience and guardrails. The strongest proven skill is architecting agent/tool integrations and resilient backend tooling as shown by the agent node graph and MCP tool registry (Accommodation_Discovery_Agent/src/agent/graph.py and src/mcp/registry.py). Public code does not show large-scale production orchestration like k8s-based deployments, multi-region scaling, or formal security audits and secret-rotation pipelines.
API Design
6/10
How well APIs are designed
Solid API design with streaming SSE, idempotency, cancel endpoint and clear error mapping; missing formal versioning strategy and wider API contract docs.
Evidence
Accommodation_Discovery_Agent/src/api/routes/search.py: uses StreamingResponse, Idempotency-Key header, cancel endpoint and explicit error exceptions
Accommodation_Discovery_Agent/src/api/server.py: app creation, lifespan, and centralized error handler
Data Layer & Database
6/10
Working with databases
Thoughtful data layer with ES index management, Redis-backed repositories and tests; no evidence of complex transactional boundaries or explicit isolation tuning.
Evidence
Accommodation_Discovery_Agent/src/infrastructure/persistence/elasticsearch/repository.py: ensure_index, store, search_hybrid, delete_old_indices
Accommodation_Discovery_Agent/src/infrastructure/persistence/redis/job_repo.py: JobRepository create/update/get and tests in tests/test_redis_repositories.py
Scalability & Performance
6/10
Handling load and speed
Resilience and scaling patterns present (retry/backoff, circuit breaker, bulkhead, caching, idempotency); system is designed for single-host deployment so operational scaling concerns remain limited.
Evidence
Accommodation_Discovery_Agent/src/infrastructure/resilience/retry.py: retry_with_backoff with jitter and retryable-exception list
Accommodation_Discovery_Agent/src/infrastructure/resilience/circuit_breaker.py and bulkhead.py: CircuitBreaker and Bulkhead implementations
System Architecture
6/10
Overall system structure
Clear modular architecture separating agent nodes, MCP tool layer, and persistence with tests and registry patterns; services are decomposed sensibly but not proven at large scale.
Evidence
Accommodation_Discovery_Agent/src/agent/graph.py and src/agent/nodes/*.py: plan-execute-evaluate-synthesize node separation
Accommodation_Discovery_Agent/src/mcp/registry.py and src/mcp/server.py: tool registry and MCP server integration
Security & Auth
5/10
Protecting data and access
Security-aware practices shown: input classifier, rate limiter, PII stripping and grounding checks; limited evidence of formal auth lifecycle, secret rotation, or dependency vulnerability management beyond CI notes.
Evidence
Accommodation_Discovery_Agent/src/guardrails/input/classifier.py and src/guardrails/input/rate_limiter.py: input sanitization and sliding-window rate limiter
Accommodation_Discovery_Agent/src/guardrails/output/pii.py and src/guardrails/output/guard.py: PII stripping and result validation
Reliability & Observability
6/10
Stability and monitoring
Robust reliability practices with timeout wrappers, retries, circuit breakers, bulkheads and cancellation support; observability (metrics/alerts) is not present in code artifacts.
Evidence
Accommodation_Discovery_Agent/src/infrastructure/resilience/timeout.py and retry.py: with_timeout and retry_with_backoff
Accommodation_Discovery_Agent/src/api/routes/search.py and frontend/src/hooks/useSearch.ts: cancel endpoint and AbortController usage for graceful cancellation
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Microservices & API Architecture• Middle
Python• Middle
Industries
Artificial Intelligence• Middle
Real Estate• Middle
Technologies
Python• since 2023 • Middle
Node JS• Middle
Rest API
FastAPI• since 2023
Prisma
Apache Kafka• since 2023
Pydantic
HTTPX
Uvicorn
Boto3
Ioredis
structlog
Text• mentioned only
Recommendations
- Develop end-to-end agentic backend features that integrate web search, scraping and LLM-based extraction with robust guardrails and idempotency.
- Build search and ingestion pipelines that persist cleansed data into Elasticsearch and Redis with clear TTL and index management.
- Implement and harden resilience patterns for external clients (retries with backoff, circuit breakers and bulkheads) in multi-service environments.
- Create developer-facing tooling for streaming results and cancellation-aware long-running requests such as agentic searches.
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 developer specializing in frontend systems and LLM-powered developer tooling at a senior level. The strongest proven skill is building deterministic code-understanding and version-grounding pipelines, evidenced by src/features/code-understanding/pipeline/* (artifact-classifier.ts, signal-extractor.ts) and the accompanying tests such as __tests__/signal-extractor.spec.ts and version-grounding/__tests__/version-grounding.spec.ts. There is limited public evidence of formal accessibility engineering, measured web performance benchmarking, or comprehensive production-grade backend operating runbooks in the analyzed human-authored frontend code.
UI Component Architecture
5/10
How interface parts are built
Component boundaries and hooks show deliberate composition and reusable logic across hooks and stores, though many UI parts are conventional and sometimes kit-derived.
Evidence
src/features/audit-dashboard/hooks/use-unified-audit.ts: custom hook coordinating processing pipeline
src/stores/app.store.ts: lightweight app store with getState/setState/subscribe
Shashank152001/Emergent-Ventures/src/Components/Profile/Profile.js: composed React component using hooks and local state
Responsive & Cross-browser
3/10
Works on all screens and browsers
Basic responsive patterns are present (Bootstrap/utility classes) and modern CSS tokens are used in places, but there is little evidence of advanced responsive strategies or RTL/i18n readiness.
Performance Optimization
4/10
Speed of the interface
Some targeted performance work (virtualization dependency, useCallback/useRef patterns and sampling / slice-based heuristics) but no measured before/after metrics or bundle-level analysis present.
Evidence
package.json (CodeSentinel): @tanstack/react-virtual listed as dependency (virtualization intent)
Shashank152001/Emergent-Ventures/src/Components/Timesheet/TimesheetForm.js: useCallback/useRef and careful state updates
src/features/code-understanding/pipeline/artifact-classifier.ts: sample-based content slicing to bound analysis work
Accessibility & Semantics
2/10
Usable for everyone
Minimal explicit accessibility work is visible; forms have labels but there is little evidence of ARIA, focus management or CI a11y tooling.
State Management & Data Flow
5/10
Managing data in the app
Clear state management patterns and server-state awareness exist (custom hooks, app store, structured agent pipelines), but advanced server-state discipline (optimistic updates with rollback, request cancellation) is not strongly evidenced.
Evidence
src/stores/app.store.ts: central app store with subscribe/reset helpers
src/features/audit-dashboard/hooks/use-unified-audit.ts: orchestrates multi-step processing pipeline
Shashank152001/Emergent-Ventures/src/Components/Timesheet/TimesheetForm.js: complex client-side form state and submission flow
UX & Visual Polish
4/10
Look and feel quality
UX attention is visible (streaming-friendly formatting, considered layout, loading/spinner usage) but many areas use conventional template UI without custom skeletons, undo patterns, or measured perceived-performance improvements.
Evidence
karuna2000/CodeSentinel/src/features/code-understanding/pipeline/artifact-classifier.ts: pragmatic content sampling to keep UI responsive
Shashank152001/Emergent-Ventures/src/Components/Spinner/Loader.js: explicit loading component used across UI
Shashank152001/Emergent-Ventures/src/Components/Profile/Profile.js: image crop modal and immediate feedback flows
Expertise
React• Middle
Frontend AI Integration• Middle
Frontend Architecture & Build Tools• Middle
Industries
Education• Middle
Software• Middle
Technologies
Tailwind CSS
Next.js
React.js
Zod
TanStack Virtual
Sketch• mentioned only
Recommendations
- Lead development of LLM-powered developer tools and streaming UIs that require careful state orchestration and live feedback (use the existing code-understanding pipelines and streaming patterns).
- Design and implement Next.js based fullstack features where server and client grounding is required, such as version-grounding, API pattern detection, and streamed reasoning responses.
- Build performant, virtualized chat or audit interfaces (use @tanstack/react-virtual and the existing hooks/store patterns) and add measured performance budgets and bundle analysis.
- Improve accessibility and measurable UX by adding axe/linting in CI, keyboard/focus management for custom widgets, and documented a11y tests.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle QA Engineer
Confidence: High SDET
A middle-level SDET and test-focused software engineer (approx. 3.0 tier) who designs and ships unit-level test suites and detection pipelines for code-understanding tooling. The strongest proven skill is building deterministic static analysis and classification logic with targeted unit tests, demonstrated by the signal-extractor implementation and its comprehensive unit tests in src/features/code-understanding/pipeline/signal-extractor.ts and src/features/code-understanding/__tests__/signal-extractor.spec.ts. There is limited public evidence of large-scale CI test orchestration, contract testing, performance/load testing, or reproducible external bug reporting workflows.
Test Automation Frameworks
4/10
Building automated tests
Test automation frameworks and basic test infrastructure are present (Vitest config, test setup file, and multiple unit test suites) but there is no evidence of advanced test infra like testcontainers, mock servers with logic, or sharding/parallelization tuning.
Test Coverage & Strategy
4/10
What and how to test
Reasonable unit and edge-case coverage for core logic (signal extraction, artifact classification, version grounding) including negative and deduplication tests, but no property-based tests, mutation testing, or explicit risk-based test stratification.
API & Integration Testing
3/10
Testing how parts work together
Small number of integration-style tests and integration test scaffolding exist, but there is no clear contract testing, schema validation tooling, or testcontainers-based integration harness.
Performance & Load Testing
Testing speed under load
Not evidenced in public code
Bug Reporting & Analysis
2/10
Finding and describing bugs
There is some evidence of edge-case thinking in tests (deduplication, capped outputs, sorted grounding sources), but there are no published reproducible bug reports, linked root-cause analyses, or explicit flaky-test investigations in the human-authored files.
CI Test Integration
3/10
Running tests automatically
Project-level test integration is present (test scripts, Vitest config and setup), indicating CI-aware test design, but there is no visible GitHub Actions workflow, per-test quarantine mechanics, selective diff-based runs, or historical test-flake artifacts in the human-authored files.
Expertise
SDET & Test Engineering• Middle
Unit & Component Testing• Middle
Industries
Artificial Intelligence• Middle
Software• Middle
Technologies
JavaScript• since 2023 • Middle
TypeScript• Middle
Playwright
Vitest
Recommendations
- Develop isolated integration test harnesses using testcontainers or local mock servers for API and ES/Redis interactions to validate end-to-end behavior.
- Add contract/schema validation for API surfaces (OpenAPI/Pact or schemathesis-style checks) and include explicit error-path tests for 4xx/5xx/timeouts.
- Introduce mutation testing or targeted property-based tests for critical classifier invariants to improve test honesty and surface brittle logic.
- Add CI workflow artifacts that run selective changed-file tests and capture historical test-flake artifacts (screenshots, traces) to strengthen pipeline integration.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: