Mohammed Al-Ameen
Software Engineer
4+ years exp
20+ projects
Node JS
TypeScript
JavaScript
Python
Go
Scalability & Performance: 4/10
System Architecture: 4/10
Active 8 days ago
+234 (816) 9919049 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Backend engineer focusing on Go developer tooling and FastAPI-style API patterns at a Middle level, with a strength in building developer-facing systems. The strongest proven skill is developer tooling and runtime orchestration as demonstrated by the HMR and watcher implementations in gv/hmr.go and gv/watcher.go. There is limited public evidence of production-grade DB schema migration histories, high-scale distributed systems design, or comprehensive security/auth lifecycle management.
Technical skills
Node JS• Junior
TypeScript
JavaScript
Python• Senior • 4y+
Go• Junior • 3y+
Node JS
Nest.JS
Go
Testify
Databases
MySQL
PostgreSQL
RabbitMQ
Supabase
AI/ML
OpenCV
DevOps
Ansible
AWS
DigitalOcean
GCP
Terraform
Containers• 4y+ • 20+ projects
CI/CD
GitHub Actions
Grafana• 2 projects
Prometheus• 2 projects
Loki• 2 projects
Frontend
GraphQL
Next.js
Svelte
Vue.js
React.js
PostCSS
Tailwind CSS• 4y+
QA
Cypress
Jest
Pytest
Mobile
Firebase
React Native
Timeline
Lead Software Engineer
•
Lead
Abinci
•
Full-Time
Led integration of a third-party payment API to receive customer orders. Supported growth to 600+ users and 7k+ transactions, contributing to NGN 1M+ monthly revenue. Designed the system to handle varying product specifications, supervised engineering for improved client-side API usage, and reviewed server code to improve performance and resource efficiency. Built CI pipelines for dev, staging, and production environments.
Senior Full-Stack Engineer
•
Senior
Tenet Security
•
Full-Time
Built and integrated AI models to support different business functionalities. Developed and documented backend APIs for seamless system integrations. Implemented an extensible authentication system using OAuth2.0 and engineered a multi-tenant frontend to support different client requirements.
Senior Backend Engineer
•
Senior
Digitvant Microfinance Bank
•
Full-Time
Integrated banking APIs to support inter-bank transfers. Built a deployment CI pipeline that published Docker containers to Kubernetes using GitHub Actions. Implemented and documented REST APIs for authentication and KYC, led client-side integration with full security oversight, and established disaster recovery measures for data loss or breach scenarios.
Docker
Kubernetes
GitHub Actions
CI/CD
Rest API
Backend Engineer
•
Middle
Triple7Events
•
Full-Time
Built payment microservices that supported multiple payment gateways behind a single access point. Implemented wallet operations microservices and coordinated deployment of four microservices, reducing deployment time by about 3x. Partnered with mobile and web developers to integrate third-party authentication across services.
Backend Engineer
•
Middle
Fintava
•
Contractor
Developed a KYC system to vet customers and reduce fraud. Authored and maintained API documentation to support third-party developers, and implemented transactional processing to track cash flow. Built multi-factor authentication to authorize sensitive transactions.
FullStack Engineer
•
Middle
Dako
•
Contractor
Built an end-to-end workflow for creating order pickups using GIS. Implemented an order-tracking user interface with map directions and responsive layouts for standard device sizes. Created a maintainable design system using Tailwind CSS.
Tailwind CSS
Backend Engineer
•
Middle
Alajo
•
Full-Time
Built a biometrics authentication system. Developed a savings scheme supporting 500+ users and NGN 4M+ revenue. Led a team in creating deployment pipelines for microservices.
Full Stack Engineer
•
Middle
Intellic Solutions
•
Full-Time
Led multiple client projects from start to completion. Built a dashboard to manage clients and their project requirements. Developed a CBT desktop software for a client and coordinated related automation efforts.
Senior Backend Developer
Confidence: Medium API Engineer
Backend engineer focusing on Go developer tooling and FastAPI-style API patterns at a Middle level, with a strength in building developer-facing systems. The strongest proven skill is developer tooling and runtime orchestration as demonstrated by the HMR and watcher implementations in gv/hmr.go and gv/watcher.go. There is limited public evidence of production-grade DB schema migration histories, high-scale distributed systems design, or comprehensive security/auth lifecycle management.
API Design
3/10
How well APIs are designed
Practical API routing and decorator-based controller mapping are present, but there is little evidence of versioning, idempotency handling, or advanced API contract/version strategies.
Evidence
struckchure/steroid/steroid/methods.py: BaseMethod and HTTP method decorators (Get/Post/Patch/etc.)
struckchure/steroid/steroid/controller.py: Controller.mapComponentsToController and setupController wiring
struckchure/steroid/docs/samples/auth_api/controllers.py: example controllers using the framework and AuthGuard
Data Layer & Database
2/10
Working with databases
Basic data-layer patterns and simple model stubs exist, but there is no migration history, advanced transaction management, or evidence of hand-tuned queries in the human-authored files.
Scalability & Performance
4/10
Handling load and speed
Clear attention to performance and concurrency in developer tooling (file watcher, HMR, plugin container) with basic deduplication and mutexing; no evidence of system-wide scaling exercises or measured optimizations.
System Architecture
4/10
Overall system structure
Deliberate module boundaries and plugin/container design are present for a build/HMR system and a FastAPI-based micro-framework, showing purposeful decomposition for tooling and API layers.
Security & Auth
2/10
Protecting data and access
Basic authentication guard and header checks exist in sample code, but there is little evidence of token lifecycle management, input-hardening at scale, dependency auditing, or explicit SQL/SSRF mitigation patterns in the human-authored artifacts.
Reliability & Observability
3/10
Stability and monitoring
Reasonable logging configuration and runtime resilience in components (panic recovery in watcher, error handling around HMR/listen), but limited evidence of structured tracing, metrics, timeouts, retries with backoff or alerting integration.
Verified artifacts
Expertise
Go Development• Junior
Python• Junior
Microservices & API Architecture• Junior
Technologies
Go• Junior • 3y+
Node JS• Junior
MySQL
PostgreSQL
Supabase
RabbitMQ
Testify
Recommendations
- Lead development of developer tooling and build-time systems (HMR, plugin containers, CLI scaffolding) using the existing gv code as a base.
- Extend the FastAPI-based framework into production-grade APIs by adding versioning, idempotency keys, pagination patterns, and concrete auth token lifecycle management.
- Invest in database work: add migration chains, schema evolution tests, and explicit transaction/isolation handling for any data-critical features.
- Add observability: instrument metrics, structured tracing (correlation ids), and error budgets or alert hooks for long-running components.
Middle DevOps Engineer
Confidence: Medium Generalist
Backend generalist (middle-level) focused on Python web APIs and small framework/tooling work with a pragmatic focus on scaffolding and request handling. The strongest proven skill is building web-framework primitives and request lifecycle glue as shown by steroid/steroid/controller.py and steroid/steroid/middleware.py. There is little to no public evidence of production-grade CI/CD pipelines, infrastructure-as-code, Kubernetes/Helm orchestration, SLO/alerting design, or cloud cost engineering.
CI/CD Pipelines
2/10
Automated build and deploy
Minimal CI/CD engineering evidence; only a container image build is present and no reusable workflows, gating, artifact signing, or advanced pipeline engineering.
Infrastructure as Code
Managing servers with code
Not evidenced in public code
Containerization & Orchestration
2/10
Working with containers
Basic containerization shown (Dockerfile and ASGI/Uvicorn-style app patterns) but no orchestration manifests, helm/kustomize, resource tuning, probes, or pod-level resilience settings.
Observability & Monitoring
3/10
Watching system health
Application-level logging and a central logging config are present, indicating awareness of observability basics, but there are no metrics, dashboards-as-code, SLOs, alerting rules or structured tracing integration.
Reliability & Incident Response
1/10
Keeping systems up
Some runtime error handling and HTTP error marshaling are implemented but there is no evidence of release/deploy strategies, rollback criteria, runbooks, chaos testing or incident artifacts.
Cloud & Cost Optimization
1/10
Smart use of the cloud
No demonstrated cloud cost or autoscaling engineering; only a Dockerfile and standard web app patterns are present.
Expertise
Observability & Monitoring• Junior
GitOps & Continuous Delivery• All Tiers
Infrastructure as Code• All Tiers
Kubernetes Ecosystem• All Tiers
Containerization & Virtualization• All Tiers
CI/CD & Pipeline Automation• All Tiers
Automation & Scripting• All Tiers
DevOps Infrastructure• All Tiers
Platform Engineering & IDP• All Tiers
Service Mesh & Networking• All Tiers
Industries
Software• Junior
Recommendations
- Develop internal FastAPI middleware, controllers and API scaffolding or developer-facing SDKs and tools (build on steroid/* modules).
- Implement and harden service-level observability (metrics + structured logs + simple dashboards) using the logging foundation in steroid/steroid/logging.py.
- Package and containerize backend services for deployment, then add simple CI/CD workflows (build, lint, test, image publish) to move from Dockerfile to reproducible pipelines.
- Take ownership of small to medium backend services (Django REST or FastAPI) including API contracts, serializers, and error handling; add infrastructure automation later.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Security Engineer
Confidence: Medium Generalist
Back-end web developer (Middle) focused on Python API frameworks and small-to-medium file-storage services. The strongest proven skill is pragmatic API and framework scaffolding, as shown by steroid/steroid/controller.py and file-storage-api/core/api/file_api.py. There is little public evidence of advanced vulnerability research, detection engineering, or cryptographic protocol design and testing.
Vulnerability Analysis
1/10
Finding security weaknesses
Little to no dedicated vulnerability analysis or PoC work; no responsible-disclosure artifacts or root-cause reports.
Evidence
file-storage-api/core/api/authentication_api.py: standard auth endpoints but no vulnerability analysis
file-storage-api/core/services/file_service.py: input handling and business logic lacking CVE/PoC artifacts
Cryptography & Secure Protocols
2/10
Using encryption correctly
Basic use of crypto primitives and token generation is visible but no evidence of correct key lifecycle, TLS/mTLS config, nonce discipline, or crypto review.
Evidence
steroid/docs/samples/auth_api/controllers.py: uses secrets.token_hex for user token generation
file-storage-api/requirements.txt: includes PyJWT (library presence) but no cryptography lifecycle or tests
Offensive Security / Pentesting
1/10
Testing by attacking
No offensive-security / pentest tooling or scoped PoCs present; nothing indicative of exploit development or chaining.
Evidence
file-storage-api/requirements.txt: no offensive pentest libraries or exploit harnesses listed
Defensive Hardening
3/10
Making systems harder to break
Evidence of basic defensive hardening patterns - structured middleware, error handling decorators, auth endpoints and container packaging - but limited depth in least-privilege IAM, input-hardening, or cloud-native security controls.
Evidence
file-storage-api/file_storage/decorators.py: centralized handle_errors decorator for API error handling
steroid/steroid/middleware.py: middleware wrapper that applies per-route PRE/POST hooks
file-storage-api/Dockerfile: containerization and startup script usage
Detection & Incident Response
2/10
Spotting and handling attacks
Some logging and observability foundations exist but no detection rules, SIEM integrations, or incident response playbooks.
Evidence
steroid/steroid/logging.py: structured logging configuration and getLogger helper
file-storage-api/core/api/authentication_api.py: login/registration flows that would feed audit trails but no IR artifacts
Compliance & Threat Modeling
1/10
Planning against threats
No threat models, STRIDE/attack-trees, compliance write-ups, or policy-to-control mappings were provided.
Evidence
file-storage-api/core/migrations/0001_initial.py: database schema present but no compliance/threat-model documents
Expertise
Application Security• Junior
Network Security• All Tiers
Industries
Software• Junior
Recommendations
- Develop REST API scaffolding, middleware, auth flows and error-handling features for internal developer platforms using FastAPI or Django.
- Implement and harden authentication/authorization flows and token lifecycle (rotate/expire/revoke), adding unit/regression tests and security-focused tests.
- Improve observability and detection by integrating structured logs, audit events, and SIEM-friendly formats; produce basic IR runbooks for common incidents.
- Harden deployments and CI/CD: add least-privilege runtime roles, image scanning, secrets management integration (Vault/HashiCorp), and security regression tests.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: