Salman Ali
Full Stack Developer
5+ years exp
Node JS
TypeScript
Python
JavaScript
Data Layer & Database: 8/10
API Design: 6/10
System Architecture: 6/10
Active 16 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Projects
Timeline
Roles
Overview
Fullstack developer (senior level) focused on transactional business systems and polished frontend experiences; strongest proven skill is backend domain modelling and transactional integrity as shown by the ERP accounting modules and integration tests that validate double-entry journals and concurrent allocation behavior; public code lacks extensive custom React component architecture and measured frontend performance engineering evidence.
Phone
Technical skills
Languages
4
Node JS
TypeScript
Python
JavaScript
Python
3
HTTPX
FastAPI
Beautiful Soup
Frontend
6
React.js
Tailwind CSS
React Router
Vite
Next.js
Vue.js
DevOps
4
Rest API
AWS
Kubernetes
API Gateway
AI/ML
4
LLM
LangChain
Claude
Gemini
Databases
3
PostgreSQL
Redis
pgvector
Other
28
Express
Prisma
Vitest
Jest
Socket.IO
GitHub
GitHub Actions
OpenAI
Docker
Linux
Terraform
Supabase
Copilot
Groq
Adjust
PostCSS
CI/CD
gRPC
Swagger
RAG
WebSockets
Embeddings
Prompt Engineering
Function Calling
Semantic Search
Dependency Injection
State Management
MVC
Projects
AI Job Copilot
Built an AI job matching tool that compares resumes and job descriptions using a vector-based retrieval pipeline. Implemented chunking, embeddings, relevance ranking, and grounded generation to produce tailored application drafts. Integrated the stack with a FastAPI service and LLM providers for semantic matching and generation.
Connect Wheels Social
Created a social car platform featuring garage profiles, listings, and real-time chat. Implemented a microservices setup with an API gateway and service-to-service communication via gRPC. Added JWT-based access control and WebSocket-based messaging for live interactions.
Timeline
Software Engineer
•
Middle
Programmers Force
•
Full-Time
Developed an authentication and role-based access control layer for an enterprise identity verification SaaS, implementing backend services with Node.js and Express and securing access with token-based auth. Built an end-to-end fintech lending platform feature set, including lender onboarding and payment flows using Stripe Connect. Improved production performance by optimizing backend query behavior and reducing frontend bundle size to lower page load times.
Node JS
Express
Stripe
Software Engineer
•
Middle
Finz Games
•
Full-Time
Built and maintained entity screening dashboards for AML and media monitoring, integrating external data provider APIs and aggregating results across many sources into unified search views. Owned backend REST API development across multiple web applications, including backend architecture and database schema design. Improved backend service performance by profiling runtime memory usage and standardizing error handling to speed up issue resolution.
Node JS
University of Management and Technology
Bachelor's Degree •
Computer Science
Senior Backend Developer
Confidence: High API Engineer
Senior backend engineer focused on Node.js and TypeScript with a strength in building reliable transactional systems for accounting and fleet domains. The strongest proven skill is transactional integrity and concurrency control, demonstrated by backend/src/modules/salesInvoice/salesInvoice.service.ts and backend/src/modules/receipt/receipt.service.ts which use Prisma transactions, row-level locking, idempotency handling, and audit logging. Public code shows little evidence of authentication/authorization layers, distributed messaging or caching strategies, or production-grade observability and rate limiting.
API Design
6/10
How well APIs are designed
API surface is coherent with clear controller/service separation, idempotency support and a client request layer, but lacks explicit versioning, global pagination strategy, or documented error contract schemas.
Evidence
erp-accounting/backend/src/routes/index.ts
erp-accounting/frontend/src/api/client.ts
erp-accounting/backend/src/modules/salesInvoice/salesInvoice.controller.ts
Data Layer & Database
8/10
Working with databases
Strong data-layer discipline: explicit multi-step Prisma transactions, careful Decimal arithmetic, SELECT ... FOR UPDATE row locking to avoid race conditions, and use of domain-scoped lookup helpers; schema evolution artifacts are implied by Prisma usage and migration scripts.
Evidence
erp-accounting/backend/src/modules/salesInvoice/salesInvoice.service.ts
erp-accounting/backend/src/modules/receipt/receipt.service.ts
erp-accounting/backend/package.json
Scalability & Performance
5/10
Handling load and speed
Good attention to concurrency and correctness (idempotency keys, row locks) but no evidence of caching strategies, queue-based decoupling, rate limiting configuration, or measured performance tuning.
Evidence
erp-accounting/backend/src/modules/receipt/receipt.service.ts
erp-accounting/backend/src/modules/payment/payment.service.ts
System Architecture
6/10
Overall system structure
Reasoned module boundaries and domain separation (accounting-engine, modules, middleware), company-scoped multi-tenancy enforcement and audit logging are clear design choices; not a distributed microservices decomposition but a well-structured monolith appropriate for the domains shown.
Evidence
erp-accounting/backend/src/accounting-engine/buildInvoiceJournal.ts
erp-accounting/backend/src/middleware/companyContext.ts
erp-accounting/backend/src/app.ts
Security & Auth
4/10
Protecting data and access
Good input validation and domain checks are present and the server recomputes critical amounts, plus idempotency protections, but there is explicitly no authentication layer and no evidence of token lifecycle, secrets management, or dependency auditing in the code inspected.
Evidence
erp-accounting/backend/src/modules/salesInvoice/salesInvoice.service.ts
erp-accounting/backend/src/lib/idempotency.ts
erp-accounting/README.md
Reliability & Observability
6/10
Stability and monitoring
Reliability is well-considered via audit logs, transactional writes and integration tests for edge cases; observability and operational tooling (metrics, tracing, retry policies, circuit breakers) are not visible in the public code.
Evidence
erp-accounting/backend/src/modules/auditLog/auditLog.service.ts
erp-accounting/backend/src/middleware/errorHandler.ts
erp-accounting/backend/tests/integration/salesInvoiceReceipt.test.ts
Expertise
Node.js• Middle
Microservices & API Architecture• Middle
Databases & Vector Storage• Middle
Industries
Financial Services• Middle
Transportation & Logistics• Middle
Technologies
Node JS• since 2021 • Senior
Rest API
gRPC
Express• since 2024
FastAPI
Prisma
Recommendations
- Build transactional financial backends and ERP modules where ledger integrity, auditability and reversal semantics are critical.
- Develop logistics and fleet-management backend services that require snapshotting, assignment history and concurrency-safe operations.
- Own backend APIs that must guarantee idempotency, multi-row transactions and row-level locking for correctness under concurrency.
- Lead implementation of domain-layer tests and integration suites for business-critical workflows in TypeScript/Prisma stacks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Frontend Developer
Confidence: Medium Fullstack
Fullstack developer (senior level) focused on transactional business systems and polished frontend experiences; strongest proven skill is backend domain modelling and transactional integrity as shown by the ERP accounting modules and integration tests that validate double-entry journals and concurrent allocation behavior; public code lacks extensive custom React component architecture and measured frontend performance engineering evidence.
UI Component Architecture
2/10
How interface parts are built
Minimal component-level architecture evidence for frontend; mostly stylesheet-based UI and some API client scaffolding rather than a deliberate component/system design.
Evidence
portfolio/src/App.css: extensive, hand-crafted CSS for UI layout and components (indicates visual design work but not component architecture)
erp-accounting/frontend/src/api/client.ts: frontend API client scaffold (shows API boundary but not component composition)
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive rules and fluid typography are present with sensible media queries and touch-friendly tweaks, but no advanced responsive techniques like container queries or explicit RTL/i18n readiness.
Evidence
portfolio/src/App.css: media queries for multiple breakpoints and clamp() used for fluid type
portfolio/src/index.css: CSS variables and global styles supporting theming and cross-browser defaults
Performance Optimization
2/10
Speed of the interface
Small practical performance touches (font preconnect, Vite-based builds) but no measured optimizations, bundle analysis, or advanced code-splitting evidence in the frontend.
Evidence
portfolio/index.html: rel=preconnect for Google Fonts
portfolio/vite.config.js: Vite config present indicating modern build tool usage
Accessibility & Semantics
2/10
Usable for everyone
Basic semantic and accessibility foundations exist (lang attr, viewport, touch-friendly styles) but no explicit ARIA, focus management, keyboard handling or CI accessibility checks are evidenced.
Evidence
portfolio/index.html: <html lang="en"> and viewport meta tag
portfolio/src/App.css: touch-friendly media query rules and reduced-pointer optimizations
State Management & Data Flow
4/10
Managing data in the app
Frontend shows an API client and context hook scaffolding with idempotency and error handling awareness; real server-state discipline is strong on the backend which influences frontend API design, but complex optimistic updates or explicit request-cancellation logic are not visible in UI code.
Evidence
erp-accounting/frontend/src/api/client.ts: ApiError class, request function and genIdempotencyKey (indicates deliberate API and idempotency handling)
erp-accounting/frontend/src/lib/useApi.ts: custom hook signature for API usage
erp-accounting/frontend/src/context/useCompany.ts: context hook signature for scoping company state
UX & Visual Polish
5/10
Look and feel quality
High visual polish and UX detail in stylesheet work for the portfolio site including transitions, gradients, hover effects and responsive layouts; however UX edge cases like skeletons, undo patterns or explicit empty-state strategies are not fully evidenced.
Evidence
portfolio/src/App.css: detailed hero, card, project and interaction styles showing careful visual design
portfolio/src/index.css: global theming variables and polished color / typography tokens
Verified artifacts
Expertise
React• Middle
Frontend Architecture & Build Tools• Middle
Industries
Financial Services• Senior
Transportation & Logistics• Senior
Technologies
JavaScript
Vue.js
Tailwind CSS
Next.js
Socket.IO
React.js
Vite
PostCSS
React Router
Recommendations
- Implement or extend transactional business logic and integrations for accounting, invoicing and financial reporting systems using Node, Prisma and Postgres.
- Build fullstack features that require reliable server-state guarantees such as payments, receipts and idempotent write paths where auditability and correctness matter.
- Polish and productize marketing or portfolio UIs and convert stylesheet work into a documented React component library with accessibility and composability improvements.
- Lead migration or standardization of frontend build tooling and repo-level conventions (Vite, TypeScript, CI) across small product teams.
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
Senior SDET and backend engineer (approx 5.0) focused on transactional, auditable backend systems for accounting and fleet domains with strong emphasis on correctness. The strongest proven skill is designing and testing transactional domain logic with integrated DB fixtures and edge-case tests as shown by erp-accounting/backend/tests/integration/salesInvoiceReceipt.test.ts. There is limited public evidence of CI pipeline integration, contract/schema testing, performance/load testing, or browser E2E automation.
Test Automation Frameworks
6/10
Building automated tests
Test automation infrastructure with real integration fixtures, Vitest configuration, and DB-scoped test helpers that provide isolated setup and cleanup; evidence of flakiness controls but no full CI matrix or browser E2E infra.
Evidence
erp-accounting/backend/tests/integration/testFixtures.ts
erp-accounting/backend/vitest.config.ts
erp-accounting/backend/tests/integration/salesInvoiceReceipt.test.ts
Test Coverage & Strategy
6/10
What and how to test
Reasoned negative-path and boundary tests are present (over-allocation, idempotency, fiscal-period closure) and assertions verify exact failure modes; however there is no evidence of property-based or mutation testing or a clear risk-based test tagging strategy.
Evidence
erp-accounting/backend/tests/integration/salesInvoiceReceipt.test.ts
API & Integration Testing
5/10
Testing how parts work together
Strong integration testing against a real DB with transactional writes, SELECT FOR UPDATE locking, idempotency handling and explicit error types; lacks contract testing tooling (Pact/Schemathesis) and explicit schema-driven response validation in tests.
Evidence
erp-accounting/backend/src/modules/receipt/receipt.service.ts
erp-accounting/backend/src/modules/salesInvoice/salesInvoice.service.ts
erp-accounting/backend/tests/integration/salesInvoiceReceipt.test.ts
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
SDET & Test Engineering• Middle
Industries
Financial Services• Senior
Transportation & Logistics• Middle
Artificial Intelligence• Middle
Technologies
Python• Middle
TypeScript• since 2025 • Senior
Swagger
Beautiful Soup
Jest
Vitest
HTTPX
GitHub• mentioned only
Recommendations
- Develop and own API integration and contract tests (e.g., Schemathesis or Pact) to harden API boundaries and enable safer refactors.
- Add CI workflows that run the integration test suite with explicit environment matrices and per-test artifact collection (logs, DB snapshots, traces).
- Introduce performance/load tests for critical write paths and reporting queries (k6 or locust) with clear SLOs and percentile analysis.
- Expand test infrastructure to include mutation testing or property-based tests for accounting invariants (balanced journal entries, idempotency invariants).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: