Cs Guy Amit
Software Developer
4+ years exp
4+ years ML exp
JavaScript
Node JS
TypeScript
API Design: 4/10
Active 5 days ago
+91 (8800) 158242
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Frontend-focused web developer producing component-based React UIs and a small Express REST backend, assessed at a junior-to-middle engineering level. The strongest proven skill is building form-driven React components and simple REST CRUD endpoints, evidenced by ZfundProject/src/Components/* and note-making/server.js. The public code shows limited investment in automated test infrastructure, CI, contract testing and performance/load validation.
Technical skills
JavaScript• Middle • 4y+
Node JS• Middle • 4y+
TypeScript• Middle
Node JS
Express• 4y+
Nest.JS
Databases
SQLite
Frontend
Vite
React.js
React Router
DevOps
Rest API
Observability
Vector• 4y+
Azure AKS• 3y+
Kubernetes• 3y+
Azure• 3y+
AI/ML
Embeddings• 4y+
Semantic Search• 4y+
Timeline
Software Development Engineer
•
Middle
Wellwiz Pvt. Ltd.
•
Full-Time
Developed and maintained an MDM system using WebSocket/WSS for remote device control, including encrypted and authenticated device communication. Enhanced an operations and project management system with NestJS and TypeScript, implementing JWT authentication and React dashboards. Optimized critical SQL queries for major performance gains. Built an end-to-end RAG pipeline over internal documents using OpenAI APIs and LangChain, including document intelligence with classification and summarization.
Nest.JS
TypeScript
Embeddings
Vector
Semantic Search
Software Development Engineer
•
Middle
Eximpedia Pte. Ltd.
•
Full-Time
Built and maintained REST APIs, webhooks, and WebSocket solutions to support scalable client-server interactions. Designed and deployed microservices on Microsoft Azure using AKS, including migration for higher availability. Implemented serverless components with latency improvements and optimized backend data processing with advanced MongoDB aggregations. Developed a RAG-based search assistant over trade data using vector embeddings and created LLM-generated trade summary reports for clients.
Azure
Azure AKS
Kubernetes
Embeddings
Vector
Associate Software Development Engineer
•
Middle
JungleWorks
•
Full-Time
Developed and maintained responsive web user interfaces and backend services, integrating external APIs and third-party services for production applications. Designed database schemas and implemented caching to improve performance and reduce load. Integrated GPT-based APIs into customer support workflows to automate ticket replies and classification. Built a prototype RAG pipeline using embeddings and semantic retrieval for an internal Q&A assistant.
Node JS
Express
JavaScript
Embeddingssince 2022
Vectorsince 2022
Semantic Searchsince 2022
Junior Backend Developer
Confidence: Medium API Engineer
Full-stack web developer (Middle) focused on building small REST APIs and interactive web tools with Node.js and front-end D3/TypeScript components. The strongest proven skill is pragmatic API & single-service application development, as shown by note-making/server.js providing a complete Express CRUD API with SQLite persistence and graceful shutdown. What is not evidenced is production-grade hardening and operational maturity such as automated migrations, tests, structured observability, auth, or scalable datastore design.
API Design
4/10
How well APIs are designed
Practical REST API implemented with clear CRUD routes and status codes but no versioning, idempotency keys, pagination strategy, or API contract tests.
Evidence
note-making/server.js: GET/POST/PUT/DELETE endpoints for /api/graphs implementing CRUD
note-making/server.js: status codes and JSON error responses in route handlers
Data Layer & Database
3/10
Working with databases
Uses a persistent SQLite schema with initialization and sample seeding, basic use of parameterized statements, but no migration history, transactional boundaries, or explicit attention to isolation and scale.
Evidence
note-making/setup.js: CREATE TABLE IF NOT EXISTS graphs (id, name, type, data, created_at, updated_at)
note-making/server.js: INSERT/UPDATE using db.run with placeholders and JSON.stringify(data)
Scalability & Performance
2/10
Handling load and speed
Minimal scalability measures; a single-file SQLite DB and no caching, connection pooling, or async/queue-based decoupling are used; some front-end performance care is visible in D3 rendering.
Evidence
note-making/server.js: SQLite used as the primary DB (single-file graphs.db)
note-making/script.js: D3 rendering and zoom controls with incremental DOM update patterns and fetch fallback logic
System Architecture
3/10
Overall system structure
Reasonable separation between static UI, API server, and DB setup files with organized front-end modules for a command reference; architecture is single-service and not microservices-oriented.
Evidence
note-making/server.js: serves static assets, API routes, and a JSON directory endpoint
Tech_Commands/src/main.ts: modular topic/section organization and render pipeline for the command reference UI
Security & Auth
2/10
Protecting data and access
Little security hardening: CORS is open, no authentication/authorization, and user-supplied paths are used directly in file-system listing, exposing directory traversal and information disclosure risk.
Evidence
note-making/server.js: app.use(cors()) enables wide-open CORS
note-making/server.js: GET /api/files reads req.query.folder directly and uses fs.existsSync(folderPath)
Reliability & Observability
3/10
Stability and monitoring
Basic reliability patterns present: error-handler middleware, try/catch in front-end fetch flows, and graceful shutdown closing the DB; observability and retry/backoff policies are not present.
Evidence
note-making/server.js: error handling middleware (app.use((err, req, res, next) => ...)) and process.on('SIGINT') to close database
note-making/script.js: try/catch around fetch with fallback to static file list and UI loading states
Expertise
Node.js• Junior
Microservices & API Architecture• Junior
Technologies
SQLite
Text• mentioned only
Recommendations
- Ship small REST services or internal tooling: extend the existing Express/SQLite service into a hardened API backed by Postgres and migration scripts
- Build developer-facing features that combine interactive visuals and APIs, e.g., dashboards or content editors using D3 and Node.js
- Improve reliability and ops: add automated migrations, unit/integration tests, structured logging and basic metrics (Prometheus/Grafana)
- Harden APIs for production: add input validation, authenticated endpoints, rate limiting, and safe handling of file-system inputs
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 (middle-level) focused on compact, client-side SPA UIs and developer-facing tooling. The strongest proven skill is implementing interactive, accessible DOM-driven interfaces and search/filter rendering as seen in Tech_Commands/src/main.ts (renderTopicNav, renderCommands) and the structured command data in Tech_Commands/src/react-elements.ts. There is little public evidence of automated tests, backend/SSR experience, large-scale system design, or measured performance optimization in the human-authored sources.
UI Component Architecture
3/10
How interface parts are built
Component-like separation exists via rendering functions and data sections, but there is no component framework, tokenized design system, or custom component library; most UI is rendered via template strings and DOM APIs.
Evidence
Tech_Commands/src/main.ts: renderCommands and renderTopicNav (DOM-rendered sections and templates)
Tech_Commands/src/react-elements.ts: REACT_ELEMENTS (structured CommandSection[] content used as UI data)
Responsive & Cross-browser
2/10
Works on all screens and browsers
Basic cross-browser and responsive considerations are present at the markup level (semantic elements and tabindex), but there is no advanced responsive strategy or feature-detection code in the human-authored files.
Evidence
Tech_Commands/src/main.ts: aside element with aria-label='Topics' and use of input type='search'
Tech_Commands/src/main.ts: topic buttons include aria-current and commands-root uses tabindex='-1'
Performance Optimization
1/10
Speed of the interface
No measured or specialized performance work is present; rendering rebuilds large innerHTML blobs and there is no virtualization, bundle analysis or explicit code-splitting shown in the human-authored code.
Evidence
Tech_Commands/src/main.ts: renderCommands constructs large innerHTML via mapping and join for the full list
Accessibility & Semantics
4/10
Usable for everyone
Clear attention to accessibility basics: aria attributes, semantic landmarks, and keyboard-focusable containers; however there are limited examples of advanced focus management for custom widgets or automated a11y tests in the human-authored files.
Evidence
Tech_Commands/src/main.ts: topic nav uses aria-label and topic buttons toggle aria-current
Tech_Commands/src/main.ts: search input sets aria-label and commands-root is given tabindex for programmatic focus
State Management & Data Flow
3/10
Managing data in the app
Local client-state is handled deliberately (filter, selectedTopicId, persistence via localStorage), with derived-state functions (filteredSections) and event-driven updates; there is no server-state handling, request cancellation, optimistic updates or advanced cache invalidation visible.
Evidence
Tech_Commands/src/main.ts: loadTopicId / saveTopicId localStorage persistence and selectedTopicId state
Tech_Commands/src/main.ts: filteredSections() and search input event handler updating filter and re-rendering
UX & Visual Polish
3/10
Look and feel quality
Good UX touches in the interactive surface such as copy-to-clipboard feedback and explicit empty-state messaging; broader visual polish is present elsewhere in the repo but the human-authored UI logic demonstrates pragmatic UX considerations rather than pixel-level design work.
Evidence
Tech_Commands/src/main.ts: clipboard copy handler updates button text to 'Copied' and falls back to 'Failed' on error
Tech_Commands/src/main.ts: renderCommands includes an explicit empty-msg when no search results match
Expertise
React• Junior
Industries
Education• Junior
Software• Junior
Technologies
JavaScript• Middle • 4y+
TypeScript• Middle
Node JS• Middle • 4y+
Nest.JS
Express• 4y+
Azure• 3y+
Kubernetes• 3y+
React.js
Vite
Azure AKS• 3y+
Vector• 4y+
React Router
Recommendations
- Use to build small-to-medium single-page developer tools and interactive documentation UIs where fast iteration and clear UX matter.
- Develop clipboard, search, and example-browsing UX for educational or reference sites (CLI/cheat-sheet apps, language references, interactive tutorials).
- Improve by adding automated tests (unit + integration), CI linting/a11y checks, and small performance benchmarks for rendering large lists.
- If expanding scope, pair this developer with a senior architect for large-scale state, server-state syncing and production performance tuning.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior QA Engineer
Confidence: Medium Generalist
Frontend-focused web developer producing component-based React UIs and a small Express REST backend, assessed at a junior-to-middle engineering level. The strongest proven skill is building form-driven React components and simple REST CRUD endpoints, evidenced by ZfundProject/src/Components/* and note-making/server.js. The public code shows limited investment in automated test infrastructure, CI, contract testing and performance/load validation.
Test Automation Frameworks
1/10
Building automated tests
Minimal test deps and a single placeholder test file exist but no test fixtures, mocks or test infra are present.
Evidence
Suitable.ai-Repo/package.json
Suitable.ai-Repo/src/App.test.js
Test Coverage & Strategy
1/10
What and how to test
No visible risk-based test strategy, negative-path or boundary tests; only CRA starter test artifacts.
Evidence
Suitable.ai-Repo/src/App.test.js
Suitable.ai-Repo/package.json
API & Integration Testing
2/10
Testing how parts work together
A simple Express CRUD API with explicit status codes and error handling exists, but there are no contract tests, schema validation or integration test harnesses.
Evidence
note-making/server.js
note-making/setup.js
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
Industries
Financial Services• Junior
Technologies
Observability
Rest API
Recommendations
- Develop and own form-driven frontend features and prototypes using React component patterns and React Router.
- Build and maintain small REST CRUD services and data seeding scripts using Express and SQLite.
- Add concrete test coverage: unit/component tests for key UI flows and API integration tests with explicit status and error-path assertions.
- Implement basic CI with test runs and artifact collection, and add simple contract/schema validation for API endpoints.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: