Karan Sharma
Software Developer
4+ years exp
Management: Under a year (1-5 people)
TypeScript
Python
Node JS
JavaScript
SQL
State Management & Data Flow: 5/10
Performance Optimization: 4/10
UX & Visual Polish: 4/10
Active 21 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Frontend app engineer focused on stateful React SPAs with a strong practical focus on robust async flows and resumable file uploads. The strongest proven skill is reliable async state and upload orchestration as implemented in the multipart upload service and the useResumableUpload hook (resumableUploadService and useResumableUpload.ts). There is limited evidence of systematic accessibility work, measured performance telemetry, unit or integration tests, or a custom component design system in the analyzed human-authored files.
Phone
Technical skills
Languages
5
TypeScript
Python
Node JS
JavaScript
SQL
Node JS
3
PM2
Axios
Express
Python
5
FastAPI
Pydantic
Asyncio
Alembic
HTTPX
Frontend
9
React.js
Next.js
React Query
Redux
GraphQL
Sass
Tailwind CSS
Zustand
Framer Motion
DevOps
6
GitHub
Git
Bitbucket
Rest API
AWS
Amazon S3
AI/ML
3
LLM
LangChain
Claude
Other
26
Figma
PostgreSQL
Redis
Playwright
React Native
Recharts
Amazon EC2
AWS Lambda
Cloudflare
Vite
Hugging Face
OpenAI
PostCSS
Docker
Vercel
Supabase
Uvicorn
AI Agents
Cursor
Groq
Webpack
RAG
autoprefixer
Databases
Structured Outputs
Chrome DevTools
Timeline
Senior Software Engineer
•
Senior
Noesis Knowledge Solutions Ltd
•
Full-Time
Developed and maintained Next.js e-commerce and customer-facing web experiences, improving checkout performance via streamlined purchase flow and payment API integration. Built an AI agent creation platform with frontend workflows and backend integrations for ingestion, configuration, and deployment. Also delivered an embeddable real-time AI support widget using a Node.js BFF and GraphQL APIs, and improved SEO and Core Web Vitals using performance-focused rendering and bundling practices. Led frontend build/deploy automation using Bitbucket Pipelines and PM2.
Next.js
React.js
React Query
Redux
GraphQL
PM2
Bitbucket
Lovely Professional University (LPU)
Master's Degree •
Computer Applications
Guru Gobind Singh Indraprastha University (GGSIPU)
Bachelor's Degree •
Computer Applications
Full-Stack Developer Intern
•
Junior
Troopr.ai
•
Full-Time
Built a Jira-based admin panel for configuration management and implemented Slack-integrated features for ticket automation. Connected frontend workflows to REST APIs to enable near real-time reporting and operational updates based on Jira events.
Jira
Slack
Rest API
Middle Frontend Developer
Confidence: High App Engineer
Frontend app engineer focused on stateful React SPAs with a strong practical focus on robust async flows and resumable file uploads. The strongest proven skill is reliable async state and upload orchestration as implemented in the multipart upload service and the useResumableUpload hook (resumableUploadService and useResumableUpload.ts). There is limited evidence of systematic accessibility work, measured performance telemetry, unit or integration tests, or a custom component design system in the analyzed human-authored files.
UI Component Architecture
3/10
How interface parts are built
Component architecture shows use of custom hooks and utility functions and separation of concerns, but there is little evidence of a bespoke component library, deliberate composition patterns or advanced boundary design beyond standard hook/service separation.
Evidence
Bytestore/frontend/lib/hooks/useDriveActions.ts
Bytestore/frontend/lib/hooks/useResumableUpload.ts
Bytestore/frontend/lib/utils.ts
Responsive & Cross-browser
3/10
Works on all screens and browsers
Responsive tooling is present via Tailwind and a global stylesheet with design tokens and container settings, but there is no advanced responsive strategy (container queries, RTL or feature detection) shown in the analyzed files.
Evidence
client-trials-dashboard/frontend/tailwind.config.ts
client-trials-dashboard/frontend/src/styles/globals.css
Performance Optimization
4/10
Speed of the interface
Practical performance work is visible - client-side caching with React Query, infinite pagination, chunked resumable uploads with retry/backoff and request cancellation - but there is no measured before/after telemetry or bundle-analysis artifacts.
Evidence
client-trials-dashboard/frontend/src/hooks/useAnalytics.ts
Bytestore/frontend/services/resumableUpload.ts
Bytestore/frontend/lib/hooks/useResumableUpload.ts
Accessibility & Semantics
1/10
Usable for everyone
Minimal accessibility signals in the inspected code; basic keyboard/focus or ARIA handling for custom widgets is not present in the analyzed files.
Evidence
Bytestore/frontend/lib/hooks/useDriveActions.ts
State Management & Data Flow
5/10
Managing data in the app
State and data flow are well-handled for typical SPA needs - React Query for server state with staleTime and placeholderData, infinite queries, a zustand filter store reference, and robust upload cancellation and retry logic demonstrate solid async discipline.
Evidence
client-trials-dashboard/frontend/src/hooks/useAnalytics.ts
Bytestore/frontend/lib/hooks/useResumableUpload.ts
Bytestore/frontend/services/resumableUpload.ts
UX & Visual Polish
4/10
Look and feel quality
UX-oriented work is evident - progress and toast feedback, upload progress lifecycle, and placeholderData to keep UI responsive - but there are limited advanced UX patterns such as explicit undo flows, rich skeleton states, or measured perceived-performance refinements.
Evidence
Bytestore/frontend/lib/hooks/useResumableUpload.ts
Bytestore/frontend/lib/hooks/useDriveActions.ts
client-trials-dashboard/frontend/src/hooks/useAnalytics.ts
Expertise
React• Middle
Web Performance & Optimization• Middle
Modern Web Frameworks• Middle
PWA & Web APIs• Middle
Industries
Health Care• Middle
Software• Middle
Technologies
JavaScript
TypeScript• since 2024 • Middle
Node JS• Middle
Zustand
Redux• since 2022
Webpack
Tailwind CSS
Next.js• since 2022
Express
Vercel
AWS
Docker
Cloudflare
React.js• since 2022
Vite
React Query• since 2022
Axios
PM2• since 2022
Sass
PostCSS
Framer Motion
Recharts
Bitbucket• since 2022
AWS Lambda
Amazon EC2
autoprefixer
Amazon S3
Recommendations
- Develop complex SPA features that require robust async control - resumable uploads, chunked transfer, cancellation and retry logic.
- Build data-rich dashboards with server-state caching, infinite scrolling and map/chart visualizations using React Query and charting libraries.
- Implement end-to-end features that integrate backend APIs with optimistic UI, shareable filter URLs and client-side caching strategies.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior AI/ML Engineer
Confidence: Low LLM Engineer
LLM engineer (Senior) specializing in building agentic LLM systems that generate SQL and interact safely with production databases. The strongest proven skill is designing and implementing an LLM-to-SQL pipeline with guardrails, repair loops and persistence, evidenced by app/services/query.py and the comprehensive unit tests covering agent generation, guardrails and query repair. There is little or no evidence of custom model training, GPU/efficiency engineering, production telemetry or experiment tracking in the public code.
Model Architecture & Training
2/10
How well models are designed and trained
LLM integration and agent design are present and well-structured but there is no custom model architecture or training; work focuses on orchestrating hosted LLMs, structured outputs and agent workflows.
Evidence
app/services/query_agent.py: LangChain-based agent creation, structured GeneratedSQL Pydantic model and llm_factory usage
backend/tests/test_query_agent.py: unit tests validating tooling, structured output handling and provider error handling
Data Pipeline & Feature Engineering
3/10
How data is prepared for models
Database metadata extraction, schema retrieval and normalization are implemented with careful handling of types and relationships but this is not large-scale ETL work.
Evidence
app/services/database_metadata.py: _build_metadata_json and table/column inspection helpers
app/services/schema_retrieval.py: SchemaRetrievalService and table scoring/tokenization logic
Experimentation & Evaluation
3/10
How results are measured and tested
Reasonable test coverage and deterministic unit tests supporting reproducibility are present; no experiment tracking or ablation study artifacts were found.
Evidence
backend/tests/: extensive unit tests for query agent, query repair, guardrails, metadata parsing and router behavior
backend/tests/test_query_service.py: many tests that validate service behavior, error cases and persistence
MLOps & Deployment
4/10
How models are shipped to production
Solid service and infra patterns for a web service - FastAPI app structure, background job dispatch, alembic migrations, rate limiting and database connection runtime are implemented for production-readiness.
Evidence
app/main.py: FastAPI app wiring, middleware and error handlers
app/services/metadata_jobs.py: Background task dispatcher and FastAPI BackgroundTasks integration
backend/alembic/*: migration scripts and env.py
Computational Efficiency
2/10
How efficiently computing resources are used
Some attention to runtime efficiency and safety - e.g., SQL statement timeouts and engine pooling - but no GPU/quantization/profiling or distributed-training optimizations.
Evidence
app/services/database_connection_runtime.py: create_engine_for_connection and QueuePool use
app/services/query_agent.py: llm_factory reads max_output_tokens and timeout configuration
Research Depth & Innovation
2/10
Depth of research and new ideas
Shows thoughtful guardrail design and an iterative repair loop for LLM-generated SQL, but no novel algorithms or paper-level research implementations.
Evidence
app/services/query_guardrails.py: BeforeGuardrail and AfterGuardrail with explicit failure categories
app/services/query_repair.py: QueryRepairLoop and AttemptRecord model capturing multiple repair attempts
Expertise
AI / LLM Engineering (Agents)• Junior
RAG• Junior
Industries
Data & Analytics• Junior
Technologies
Databases
Python• since 2025 • Junior
SQL• since 2026
PostgreSQL
Redis
Supabase
Cursor
LangChain
Claude
Groq
AI Agents
LLM
RAG
Pydantic
HTTPX
Alembic
OpenAI
Hugging Face
Structured Outputs
Recommendations
- Develop LLM-driven data exploration and analytics features that leverage the existing schema retrieval, guardrails and repair loop to safely expose insights to non-technical users.
- Implement observability and MLops integrations - token usage metrics, model-provider latency/cost tracking and alerting - to make the LLM production-ready and monitor drift or regressions.
- Extend provider abstractions and add configurable rate-limiting and backoff strategies for multi-provider failover, plus end-to-end integration tests simulating provider outages.
Junior Backend Developer
Confidence: Low Data Platform
Middle-level backend data engineer specializing in analytical backends and MongoDB aggregation. The strongest proven skill is writing efficient MongoDB aggregation pipelines and analytics logic as shown in client-trials-dashboard/backend/services/analytics_service.py. There is limited evidence of production-grade observability, distributed system patterns, or robust authentication and secret management in the human-authored code.
API Design
4/10
How well APIs are designed
Clean REST API design with validated query parameters, pagination and consistent response models; lacks explicit versioning and idempotency mechanisms.
Evidence
client-trials-dashboard/backend/routers/analytics.py: endpoints with Query param validation, page/page_size pagination and response_model usage
client-trials-dashboard/frontend/src/api/analytics.ts: client wrappers that mirror router query params and error handling
client-trials-dashboard/frontend/src/hooks/useAnalytics.ts: useQuery/useInfiniteQuery usage showing client-side contract expectations
Data Layer & Database
5/10
Working with databases
Deliberate data-layer work with non-trivial MongoDB aggregation pipelines, bucketing and projection plus a bulk seeding workflow.
Evidence
client-trials-dashboard/backend/services/analytics_service.py: complex aggregation pipelines using $facet, $unwind, $group, $bucket and targeted projection
client-trials-dashboard/backend/seed.py: bulk upsert via pymongo UpdateOne and bulk_write
Scalability & Performance
4/10
Handling load and speed
Thoughtful performance patterns including server-side aggregation, result limiting and caching with TTLs; no evidence of rate limiting, measured load testing or queue-based decoupling.
Evidence
client-trials-dashboard/backend/routers/analytics.py: cache_get/cache_set usage with specific TTLs per endpoint
client-trials-dashboard/backend/services/analytics_service.py: use of $limit, $project and $group to reduce result size
System Architecture
4/10
Overall system structure
Sensible separation between routers, service layer and client code with clear responsibilities and thin controllers.
Evidence
client-trials-dashboard/backend/routers/analytics.py: thin router delegating to services and cache layer
client-trials-dashboard/backend/services/analytics_service.py: dedicated service implementing domain logic
Security & Auth
3/10
Protecting data and access
Basic input validation and sanitization are present including safe regex escaping and parameter constraints; no authentication or secrets lifecycle management shown in the human-authored code.
Evidence
client-trials-dashboard/backend/services/analytics_service.py: search uses re.escape to sanitize user-provided search strings
client-trials-dashboard/backend/routers/analytics.py: Query param constraints (e.g. limit bounds, page bounds)
Reliability & Observability
2/10
Stability and monitoring
Minimal reliability and observability patterns in these files - client-side stale/caching hints exist but no retries with backoff, structured logging or metrics/alerts surfaced.
Evidence
client-trials-dashboard/frontend/src/hooks/useAnalytics.ts: useQuery placeholderData and staleTime used for UX resilience
client-trials-dashboard/backend/routers/analytics.py: cache fallback pattern but no retry or circuit breaker logic
Expertise
Python• Junior
Databases & Vector Storage• Junior
Industries
Health Care• Middle
Data & Analytics• Junior
Technologies
Rest API• since 2022
GraphQL• since 2022
FastAPI
Asyncio
Uvicorn
Recommendations
- Implement analytics APIs and ETL pipelines that rely on MongoDB aggregation and bulk ingestion workflows
- Build data services where caching with sensible TTLs and paginated APIs are required
- Help migrate or optimize complex aggregation queries and create indexes or explain plans for performance tuning
- Develop backend endpoints for dashboards that need careful input sanitization and search/pagination semantics
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: