Keshava Mudumal
.NET Developer
JavaScript
Python
C#
SQL
Security & Auth: 7/10
API Design: 6/10
System Architecture: 6/10
Active 6 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A backend API engineer (approx mid-level) who organizes .NET web services with a clear layered architecture and a focus on secure authentication. The strongest proven skill is secure token and auth design as implemented in Infrastructure/Identity/JwtTokenService.cs together with refresh token rotation in Application/Services/AuthService.cs. What is not evidenced is a migration history and strong production operations artefacts such as retries/backoff, structured metrics and advanced DB tuning.
Phone
Technical skills
Languages
4
JavaScript
Python
C#
SQL
C#
3
Entity Framework Core
ASP.NET Core
FluentValidation
Other
20
LLM
React.js
Claude
Azure
.NET
Playwright
Rest API
Azure SQL Database
MS SQL
GitHub
RAG
Git
Swagger
Embeddings
Copilot
Apache HTTP Server
CI/CD
JMeter
Quantization
Structured Outputs
Timeline
Engineer - AI
•
Middle
GroundGame.Health
•
Full-Time
Built and shipped features for multiple production healthcare platforms using React and .NET. Worked across UI, REST API, and SQL layers with validation and role-based access, and supported CI/CD deployments. Developed Playwright regression suites and Apache JMeter load tests, reducing regression cycle time and helping diagnose issues across the full stack.
React.js
C#
ASP.NET Core
Rest API
MS SQL
CI/CD
Playwright
JMeter
AI Intern
•
Junior
Tech Bharat AI
•
Internship
Engineered Python retrieval-augmented generation pipelines for document retrieval and question answering, including embeddings, vector search, and response validation. Benchmarked model outputs using text and semantic similarity metrics and improved inference latency through quantization and batching. Produced structured outputs and evaluated model behavior for quality control.
Python
RAG
Embeddings
LLM
Quantization
Structured Outputs
Middle Backend Developer
Confidence: Medium API Engineer
A backend API engineer (approx mid-level) who organizes .NET web services with a clear layered architecture and a focus on secure authentication. The strongest proven skill is secure token and auth design as implemented in Infrastructure/Identity/JwtTokenService.cs together with refresh token rotation in Application/Services/AuthService.cs. What is not evidenced is a migration history and strong production operations artefacts such as retries/backoff, structured metrics and advanced DB tuning.
API Design
6/10
How well APIs are designed
Well-structured REST API with versioning, role-based authorization, pagination and ProblemDetails-based error handling; lacks idempotency keys and a documented error contract for all endpoints.
Data Layer & Database
5/10
Working with databases
Repository + UnitOfWork pattern and EF Core entity configurations are present and used consistently; no visible migration chain or hand-tuned SQL/indexing in the provided files.
Scalability & Performance
4/10
Handling load and speed
Basic operational features are present (response compression, health checks); lacks explicit caching/invalidation, queueing, rate limiting or measured performance tuning for DB queries.
System Architecture
6/10
Overall system structure
Clear modular separation (API, Application, Domain, Infrastructure) with explicit dependency injection wiring; design is deliberate for testability but this is a small single-service boundary rather than multi-service decomposition.
Security & Auth
7/10
Protecting data and access
Strong authentication and token design: signed JWTs with key-length validation, opaque refresh tokens with hashing and rotation, PBKDF2 hasher and security headers; good awareness of token lifecycle and secrets usage in config.
Reliability & Observability
5/10
Stability and monitoring
Exception handling middleware, health checks and unit tests are present, showing basic observability and reliability consideration; missing are systematic retries/backoff, circuit breakers, structured correlation ids and production metrics/alerting artifacts.
Expertise
.NET• Middle
Technologies
Rest API• since 2026
.NET
Rocket• mentioned only
Recommendations
- Develop secure, versioned REST APIs with JWT-based auth and refresh-token rotation for small-to-medium services.
- Implement transactional business logic that requires repository + UnitOfWork patterns and automated tests for core domain services.
- Deliver backend features where clear separation of concerns (API/Application/Domain/Infrastructure) and FluentValidation are required.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium App Engineer
Frontend app engineer (Middle) specializing in small-to-medium React and React Native applications with pragmatic UI and state management. The strongest proven skill is building interactive list and navigation flows in React Native, evidenced by LaunchListScreen.js with search, filters, FlatList and StackNavigator.js. The public code lacks evidence of advanced server-state strategies, request cancellation, comprehensive accessibility work, or automated tests.
UI Component Architecture
3/10
How interface parts are built
Component boundaries are reasonable for app screens and small reusable components, but there is no evidence of a custom design system, advanced composition patterns, or custom lifecycle hooks beyond simple components.
Evidence
spacex-launches-app/app/screens/LaunchListScreen.js: List+filter+search component with local state and styles
spacex-launches-app/app/components/CountdownTimer.js: small reusable timer component with cleanup
Chess/src/Components/Board.js: encapsulated board logic with undo history
Responsive & Cross-browser
2/10
Works on all screens and browsers
Basic responsive/layout practices are present (flex layout in React Native and simple CSS for web) but there is no deliberate responsive strategy, RTL/i18n readiness, or feature detection.
Evidence
spacex-launches-app/app/screens/LaunchListScreen.js: styles using flex and padding for layout
Chess/src/App.css: CSS layout for board and cells
Performance Optimization
3/10
Speed of the interface
Some performance-aware choices (FlatList for lists, and a web-vitals perf hook) show awareness, but there is no measured optimization, bundle analysis, code-splitting, or virtualization beyond FlatList.
Evidence
spacex-launches-app/app/screens/LaunchListScreen.js: uses FlatList for launch list rendering
Chess/src/reportWebVitals.js: web-vitals integration for measuring runtime performance
Accessibility & Semantics
1/10
Usable for everyone
Minimal accessibility work is evident; default components are used but no ARIA or keyboard/focus management on custom widgets and no accessibility testing tooling is present.
Evidence
spacex-launches-app/app/screens/LaunchListScreen.js: TouchableOpacity items rendered without accessibilityLabel or explicit accessibility props
spacex-launches-app/app/screens/LaunchDetailsScreen.js: image and text shown but no accessibility attributes or focus management
State Management & Data Flow
3/10
Managing data in the app
State and data flows are implemented end-to-end with loading and error states and simple service functions; there is local undo history in the board game, but no advanced server-state management (caching, invalidation, cancellation or optimistic rollback).
Evidence
spacex-launches-app/app/services/spacexApi.js: getLaunches and getRocketById with basic fetch and error handling
spacex-launches-app/app/screens/LaunchListScreen.js: fetchLaunches with loading/error state and filtering
Chess/src/Components/Board.js: history array and handleUndo implementing undo semantics
UX & Visual Polish
3/10
Look and feel quality
UX covers essential edge states (loading and error screens) and includes useful features like undo and countdown timers, but lacks advanced perceived-performance patterns, skeletons, or undo/redo UX polish at scale.
Evidence
spacex-launches-app/app/screens/LaunchListScreen.js: ActivityIndicator loading and basic error UI
spacex-launches-app/app/screens/LaunchDetailsScreen.js: loading/error handling and mission details layout
Chess/src/Components/Board.js: UndoButton integration and visual feedback via CSS
Expertise
React• Middle
HTML & CSS• Middle
Industries
Space & Aerospace• Middle
Technologies
JavaScript• since 2024 • Middle
React.js• since 2026
UI• mentioned only
Recommendations
- Lead development of list-heavy mobile screens and navigation flows in React Native, including filter/search UX and detail screens.
- Add focused improvements: server-state handling (caching, request cancellation), automated tests, and accessibility fixes to raise production-readiness.
- Implement measured performance optimizations (LCP/INP tracking, bundle analysis, and code-splitting) and add skeletons or optimistic UI where appropriate.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle QA Engineer
Confidence: Medium Generalist
Backend API developer (senior-level by architecture) specializing in secure, versioned ASP.NET Core services with token-based authentication. The strongest proven skill is building secure authentication and token rotation logic as evidenced by JwtTokenService.cs and AuthService.cs implementing access token issuance, refresh token hashing and rotation. Tests and CI/test-infra are not evidenced in the human-authored files and there is little public material for contract testing, performance testing or CI integration.
Test Automation Frameworks
2/10
Building automated tests
Small set of unit/endpoint tests exist but no dedicated test fixtures, parallelization, or test infra are present in human-authored files.
Test Coverage & Strategy
2/10
What and how to test
Validation rules and some unit tests are present indicating attention to input constraints, but there is little evidence of a deliberate risk-based test strategy or property/negative-path heavy suites.
API & Integration Testing
3/10
Testing how parts work together
API design shows versioning, Swagger/OpenAPI and health checks and there are endpoint tests, but no contract tooling (Pact/Schemathesis) or deep error-path integration tests were found.
Performance & Load Testing
Testing speed under load
Not evidenced in public code
Bug Reporting & Analysis
Finding and describing bugs
Not evidenced in public code
CI Test Integration
Running tests automatically
Not evidenced in public code
Expertise
API Testing & Contract Validation• Junior
Unit & Component Testing• Junior
Technologies
C#• since 2026 • Middle
JMeter• since 2026
Playwright• since 2026
Swagger
ASP.NET Core• since 2026
Entity Framework Core
FluentValidation
Recommendations
- Develop secure backend APIs and authentication/token services in ASP.NET Core using layered architecture and DI.
- Implement domain-focused CRUD services with clear validation rules and unit tests for negative and boundary cases.
- Build small-to-medium enterprise features that require audit fields, pagination and repository+unit-of-work patterns.
- Harden testing by adding contract tests, property-based negative-path suites and CI test matrix integration.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: