Muhammad Khan
Software Developer
10+ years exp
Go
PHP
SQL
C#
JavaScript
Node JS
Python
TypeScript
Ruby
API Design: 5/10
System Architecture: 5/10
Data Layer & Database: 4/10
Active 3 days ago
+351 (91) 2445638 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Backend API engineer at a senior level whose primary strength is building clear, domain-rich server-side logic and business-rule engines; this is evidenced by a standalone HOS compliance engine that implements FMCSA rules and is covered by comprehensive tests (apps/hos/engine.py and apps/hos/tests/test_engine.py). The codebase also shows solid API design and integration work (DRF viewsets, JWT auth, PDF generation) but lacks public evidence of large-scale distributed systems design, measured performance tuning, or full production observability pipelines.
Technical skills
Go
PHP
SQL
C#
JavaScript
Node JS• Senior • 10y+
Python• Senior • 10y+
TypeScript• Senior • 10y+
Ruby• Senior
PHP
Laravel• 10y+
C#
.NET• 10y+
Node JS
Express
Python
Django
Django REST Framework
Ruby
Ruby on Rails
Puma
Minitest
Databases
Azure SQL Database
SQLite
MS SQL
MySQL• 10y+
PostgreSQL• 10y+
DevOps
AWS
Azure
Azure DevOps
CI/CD
Rest API
WebSockets
Containers
Docker Compose
Docker• 10y+
Kubernetes• 10y+
Amazon EC2• 8y+
Amazon EKS• 6y+
AWS Lambda• 6y+
Pulumi• 6y+
Terraform• 6y+
QA
Vitest
QA
Frontend
GraphQL
Zod
React.js• 10y+
Vue.js• 8y+
Timeline
Senior Full-Stack Software Engineer
•
Senior
Nexologics
•
Full-Time
Delivered scalable full-stack applications using Laravel, Python, and Node.js with React, Vue, and AngularJS-based front ends. Built RESTful APIs and backend services for authentication, authorization, automation, and multi-tenant SaaS operations. Integrated AI/ML workflows and OpenAI APIs into production systems and led cloud-native deployments on AWS with Docker and Kubernetes. Improved PostgreSQL/MySQL performance and added monitoring and observability for reliable operations.
Laravel
Python
Node JS
React.js
Vue.js
Amazon EC2
Amazon EKS
AWS Lambda
Terraform
Pulumi
Docker
Kubernetes
PostgreSQL
MySQL
Team Lead / Full Stack Engineer
•
Lead
Join Smartly
•
Full-Time
Led a distributed engineering team building multi-tenant SaaS platforms with Vue, React, AngularJS, Laravel, and Node.js. Designed API-driven backend services and microservices for financial workflows, adding Python services for automation via REST integrations. Improved relational database performance for PostgreSQL and MySQL and introduced event-driven design with Docker and Kubernetes. Managed AWS infrastructure with CI/CD automation and aligned system architecture with Agile business objectives.
Vue.jssince 2018
React.js
Laravel
Node JS
Python
Amazon EC2since 2018
PostgreSQL
MySQL
Docker
Kubernetes
Software Engineer
•
Middle
Cloud Pacer
•
Full-Time
Developed and maintained full-stack web applications for retail and logistics clients across frontend, backend, cloud, and database layers. Built dashboards and reporting using React and AngularJS with TypeScript and REST APIs. Implemented backend services with Laravel, Node.js, Python, and .NET Core, and optimized MySQL and PostgreSQL schemas for performance and data integrity. Supported production reliability by troubleshooting issues and assisting with Docker, Kubernetes, and CI/CD workflows.
React.jssince 2016
TypeScript
Laravelsince 2016
Node JSsince 2016
Pythonsince 2016
.NET
PostgreSQLsince 2016
MySQLsince 2016
Dockersince 2016
Kubernetessince 2016
Lahore University of Management Sciences (LUMS)
Bachelor's Degree •
Computer Sciences
Senior Backend Developer
Confidence: Medium API Engineer
Backend API engineer at a senior level whose primary strength is building clear, domain-rich server-side logic and business-rule engines; this is evidenced by a standalone HOS compliance engine that implements FMCSA rules and is covered by comprehensive tests (apps/hos/engine.py and apps/hos/tests/test_engine.py). The codebase also shows solid API design and integration work (DRF viewsets, JWT auth, PDF generation) but lacks public evidence of large-scale distributed systems design, measured performance tuning, or full production observability pipelines.
API Design
5/10
How well APIs are designed
Solid API design and error-contract thinking with DRF viewsets, throttling, OpenAPI schema and a typed client that maps rate limits to structured errors; missing explicit versioning, idempotency key patterns and a documented error-code matrix.
Evidence
ddl-app/backend/apps/trips/views.py - TripViewSet with @action and ScopedRateThrottle usage
ddl-app/backend/config/urls.py - OpenAPI schema route (drf_spectacular) configured
github-repo-search/src/services/github.ts - typed GithubClient with rate-limit detection and error mapping
Data Layer & Database
4/10
Working with databases
Mature data model with migrations and sensible seeding; evidence of schema evolution (multiple migrations) and bulk operations but limited explicit transaction boundaries or advanced tunings (no explicit isolation-level handling or hand-tuned SQL).
Evidence
ddl-app/backend/apps/hos/migrations/0002_auditlog.py - follow-up migration
ddl-app/backend/apps/accounts/migrations/0001_initial.py - initial migration for accounts
ddl-app/backend/apps/trips/management/commands/seed_data.py - get_or_create and bulk_create patterns for realistic seed data
Scalability & Performance
3/10
Handling load and speed
Some scalability thinking present (server worker/thread config and client-side debounce/abort), but no measured performance work, benchmarking artifacts or caching/invalidation strategies implemented for high-load scenarios.
Evidence
sms-notifications-system/config/puma.rb - worker and thread configuration for production
github-repo-search/src/composables/useRepoSearch.ts - client-side debounce, request aborting and pagination cap enforcement
sms-notifications-system/config/environments/production.rb - production logging and force_ssl settings
System Architecture
5/10
Overall system structure
Clear modular architecture and separation of concerns: domain-heavy pure-Python HOS engine decoupled from Django, services layer for trip planning, and a dedicated PDF generator; shows deliberate module boundaries for maintainability.
Evidence
ddl-app/backend/apps/hos/engine.py - standalone HOS compliance engine implementing FMCSA rules
ddl-app/backend/apps/trips/services.py - RouteService and TripPlannerService encapsulating route and planning logic
ddl-app/backend/apps/pdf_gen/generator.py - RODS PDF generator separated from views
Security & Auth
4/10
Protecting data and access
Reasonable auth and input-validation basics: JWT-based auth, model validations and some rate/throttle protections; secrets and token lifecycle patterns are conventional but token revocation and advanced auth lifecycle are not evident.
Evidence
ddl-app/backend/apps/accounts/urls.py - TokenObtainPairView / TokenRefreshView integration
sms-notifications-system/app/models/user.rb - email and phone validations and after_commit notification flow
sms-notifications-system/config/environments/production.rb - force_ssl and logging/tagging configuration
Reliability & Observability
4/10
Stability and monitoring
Good automated test coverage and logging configuration; unit and integration tests exercise many edge cases, but advanced reliability patterns (distributed tracing, backoff strategies, circuit breakers, or multi-process graceful shutdown) are limited or not present.
Evidence
ddl-app/backend/apps/hos/tests/test_engine.py - extensive unit tests covering edge cases of the rules engine
ddl-app/backend/apps/trips/tests/test_views.py - integration tests including PDF generation and API endpoints
sms-notifications-system/config/environments/production.rb - logging to STDOUT and request_id tagging
Verified artifacts
Expertise
Python• Senior
Microservices & API Architecture• Senior
Messaging & Real-time• Middle
Industries
Transportation & Logistics• Senior
Technologies
Go
PHP
SQL
C#
Node JS• Senior • 10y+
MySQL• 10y+
PostgreSQL• 10y+
.NET• 10y+
Terraform• 6y+
Express
Laravel• 10y+
Azure DevOps
Pulumi• 6y+
Azure
MS SQL
CI/CD
SQLite
AWS
Docker• 10y+
Kubernetes• 10y+
Django REST Framework
Azure SQL Database
Amazon EKS• 6y+
AWS Lambda• 6y+
Amazon EC2• 8y+
Recommendations
- Build domain-heavy backend services that require complex business rules and rigorous unit testing, for example compliance engines or financial/mobility rule evaluators.
- Develop REST APIs and integrations where typed error contracts, throttling, and client resilience are important.
- Implement deterministic report generation and document-export pipelines (PDF generation merging templates and overlays).
- Add production-grade observability and scaling work (tracing, SLI/SLOs, load-testing and cache invalidation strategies) as a next growth area.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior DevOps Engineer
Confidence: Medium Generalist
HOS compliance and backend engineer (senior-level) focused on building a domain-specific Hours-of-Service compliance engine for transportation. The strongest proven skill is implementing complex domain logic with good test coverage, demonstrated by apps/hos/engine.py and the comprehensive unit tests in apps/hos/tests/test_engine.py. What is not evidenced is production-grade CI/CD, remote IaC (Terraform/Pulumi) or cloud autoscaling and deployment strategies in the public code.
CI/CD Pipelines
Automated build and deploy
Not evidenced in public code
Infrastructure as Code
2/10
Managing servers with code
Basic local infra and container orchestration as code is present (Dockerfiles, docker-compose) but there are no versioned IaC modules, remote state, state migrations, or environment-segregated Terraform/Pulumi artifacts.
Evidence
ddl-app/docker-compose.yml: docker-compose service definitions for db/backend/frontend
ddl-app/backend/Dockerfile: Python web app Dockerfile used to build backend image
sms-notifications-system/Dockerfile: multi-stage Rails Dockerfile used for building and deploying the app
Containerization & Orchestration
3/10
Working with containers
Concrete containerization work exists: multi-stage Dockerfile for Rails, non-root runtime user, and a docker-compose orchestration for local dev. No Kubernetes manifests, resource requests/limits, probes, PDBs, or GitOps manifests were found.
Evidence
sms-notifications-system/Dockerfile: multi-stage build and non-root runtime user
ddl-app/backend/Dockerfile: Python app image and gunicorn CMD
ddl-app/docker-compose.yml: local orchestration of db/backend/frontend
Observability & Monitoring
2/10
Watching system health
Basic observability configuration is present (structured logging settings and log tags in Rails production configuration). There are no SLOs, burn-rate alerts, Prometheus/Alertmanager, tracing, or dashboards-as-code artifacts.
Evidence
sms-notifications-system/config/environments/production.rb: log_level, log_tags and logger configuration
sms-notifications-system/config/puma.rb: process/worker tuning and production worker guidance
Reliability & Incident Response
2/10
Keeping systems up
Some reliability-focused choices (Puma worker guidance, non-root runtime in container, seeding and test coverage) are present but there are no deploy strategies (canary/blue-green), runbooks, rollback gates, DR rehearsals, or incident-postmortems.
Evidence
sms-notifications-system/config/puma.rb: worker and preload_app guidance for production
ddl-app/backend/apps/trips/management/commands/seed_data.py: seed command for deterministic demo data
ddl-app/backend/apps/hos/tests/test_engine.py: comprehensive unit tests for the HOS engine
Cloud & Cost Optimization
1/10
Smart use of the cloud
No cloud cost or autoscaling strategies are implemented; only basic container images and environment variable use are present without autoscaler/HPA, spot/eviction handling, rightsizing or IAM/workload-identity evidence.
Evidence
ddl-app/docker-compose.yml: environment variables and service definitions (local development oriented)
sms-notifications-system/config/database.yml: environment-driven production DB password reference
Expertise
Observability & Monitoring• Junior
Platform Engineering & IDP• Junior
Industries
Transportation & Logistics• Senior
Technologies
Containers
Python• Senior • 10y+
Ruby• Senior
Rest API
Docker Compose
Ruby on Rails
Django
Puma
Ruby• mentioned only
Recommendations
- Develop domain-specific compliance engines and business-logic services for transportation and logistics (HOS rules, trip planning and scheduling).
- Build backend REST APIs and PDF/reporting pipelines that require careful edge-case handling and deterministic unit tests.
- Implement medium-scale web services and internal admin UIs where domain rules and integration with databases are the main complexity.
- Work on improving platform delivery by adding CI/CD pipelines, IaC (Terraform/Pulumi modules), and production deployment strategies (canary/rollbacks).
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior QA Engineer
Confidence: High API QA Engineer
Full-stack web engineer (senior-level) focused on robust frontend API clients and defensive error handling with an emphasis on unit and component testing. The strongest proven skill is designing a typed GitHub API client with explicit HTTP error mapping and comprehensive unit tests, as shown in src/services/github.ts and the tests in src/services/github.spec.ts and src/composables/useRepoSearch.spec.ts. There is little or no public evidence of CI pipelines, contract testing, dedicated performance/load testing, or formal bug-tracking and RCA artifacts.
Test Automation Frameworks
5/10
Building automated tests
Component and unit test usage is solid (Vitest + Vue Test Utils) with mocking, fake timers and scoped mounts, but there is no evidence of large-scale test infrastructure, parallelization, or testcontainers.
Evidence
github-repo-search/src/composables/useRepoSearch.spec.ts
github-repo-search/src/services/github.spec.ts
github-repo-search/src/views/SearchView.url.spec.ts
Test Coverage & Strategy
6/10
What and how to test
Tests show explicit negative-path and boundary coverage (rate limits, aborts, pagination caps, empty states and error kinds) and risk-focused assertions rather than only happy-path checks.
Evidence
github-repo-search/src/composables/useRepoSearch.spec.ts
github-repo-search/src/services/github.spec.ts
API & Integration Testing
6/10
Testing how parts work together
Strong API client testing with injected/mock fetch, detailed HTTP-status handling (rate-limit, 422, 403, 404) and mapping to typed errors; no full contract tooling (Pact/Schemathesis) observed.
Evidence
github-repo-search/src/services/github.ts
github-repo-search/src/services/github.spec.ts
Performance & Load Testing
2/10
Testing speed under load
Some production server tuning (Puma config) exists but there are no dedicated performance or load test artifacts (k6, Gatling, Locust) or SLO/percentile analysis.
Evidence
sms-notifications-system/config/puma.rb
Bug Reporting & Analysis
1/10
Finding and describing bugs
No public reproducible bug reports, issue RCAs, or linked fixes were found; tests demonstrate investigation of edge cases but not formal bug-tracking artifacts.
Evidence
github-repo-search/src/composables/useRepoSearch.spec.ts
CI Test Integration
2/10
Running tests automatically
Local test scripts are present in package.json and test suites run via Vitest/Minitest, but no CI workflows, matrix configuration, artifact collection or quarantine/retry policies are visible.
Evidence
github-repo-search/package.json
sms-notifications-system/frontend/package.json
Expertise
Unit & Component Testing• Middle
SDET & Test Engineering• Middle
Technologies
QA
TypeScript• Senior • 10y+
WebSockets
Vitest
Minitest
Recommendations
- Develop resilient typed API client libraries and SDKs with exhaustive unit tests and explicit HTTP error mapping (similar to src/services/github.ts).
- Build component-level and composable state tests for complex UI timing and cancellation scenarios (debounce/abort/pagination patterns used in useRepoSearch).
- Implement CI integration including per-test artifact capture, selective runs on diffs and quarantine/retry policies to surface flakiness before merging.
- Extend testing to include contract testing or lightweight integration tests (Pact/Schemathesis or testcontainers) and add basic load tests for critical endpoints.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: