Tamer Taji
DevOps Engineer
5+ years exp
Bash
Python
Node JS
Java
JavaScript
Infrastructure as Code: 4/10
Containerization & Orchestration: 4/10
Active 2 days ago
+972 (58) 7660550
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A cloud-focused DevOps practitioner at a mid-level specializing in Terraform-driven AWS infrastructure and container deployments. The strongest proven skill is Terraform-based AWS orchestration with an S3 remote backend and an EKS module demonstrated in SmartPath-AI_Infra/main.tf and providers.tf. There is limited evidence of advanced pipeline engineering, release gating, SLO-driven monitoring or documented incident runbooks in public code.
Technical skills
Bash
Python
Node JS• Junior
Java• 5y+
JavaScript• Junior • 3y+
Node JS
Axios
Cheerio
Dotenv
Express
Mongoose
Databases
MySQL
MongoDB• 5y+
Frontend
Next.js
React.js
Bootstrap
DevOps
Amazon EKS
AWS Fargate
Azure
CI/CD
Docker
Git
GitHub Actions
Helm
Jenkins
Kubernetes
Terraform
Prometheus
Containers
Docker Compose
Grafana
Amazon EC2
AWS
Design
Figma
Timeline
Cloud-native AI application deployed on AWS EKS using Terraform, Github Actions CI/CD, ArgoCD GitOps and observability via Prometheus, Grafana.
Designed and implemented a highly available containerized application architecture on AWS.
· Provisioned a secure cloud infrastructure using Terraform, including a VPC with public/private subnets, Internet Gateway, and NAT Gateway.
· Deployed a Dockerized application on Amazon ECS (Fargate) behind an Application Load Balancer, ensuring secure internet exposure and high availability with multiple running tasks.
· Implemented CI/CD automation using GitHub Actions, building Docker images, pushing to Amazon ECR, and performing rolling deployments to ECS
Afeka College of Engineering
Non-Degree Program •
DevOps
Afeka College of Engineering
Bachelor's Degree •
software engineering
Developed a cloud-native SaaS application to demonstrate CI/CD workflows, microservices deployment, and infrastructure automation.
· Integrated Next.js, Node.js and React for seamless frontend-backend interaction.
· Optimized CI/CD automation with GitHub Actions, implemented Docker for containerization, and used Terraform for AWS resource provisioning.
· Deployed microservices with Helm charts and Kubernetes (EKS), ensuring scalable and efficient cloud architecture.
Built a cloud-enabled Python web application with Flask and MySQL backend, following CI/CD best practices.
· Utilized Docker Compose for environment consistency and GitHub Actions for automated build, testing, and deployment.
· Integrated AWS ECR for Docker image versioning and deployed the application securely on EC2, providing a production-like environment for live tracking.
Middle DevOps Engineer
Confidence: Medium Cloud Architect
A cloud-focused DevOps practitioner at a mid-level specializing in Terraform-driven AWS infrastructure and container deployments. The strongest proven skill is Terraform-based AWS orchestration with an S3 remote backend and an EKS module demonstrated in SmartPath-AI_Infra/main.tf and providers.tf. There is limited evidence of advanced pipeline engineering, release gating, SLO-driven monitoring or documented incident runbooks in public code.
CI/CD Pipelines
2/10
Automated build and deploy
Basic, working CI pipelines with tests, build and ECR push exist but they are simple, use runner-local Docker/DinD patterns and lack reusable workflows, gating, signing or advanced release controls.
Infrastructure as Code
4/10
Managing servers with code
Real Terraform usage with modules, an S3 remote backend and composed EKS resources shows practical IaC ability, but lacks explicit state-locking, lifecycle management examples, state migrations, or infra tests.
Evidence
Containerization & Orchestration
4/10
Working with containers
Multiple container orchestration targets (ECS Fargate, EKS, Docker Compose) and Dockerfiles are present with resource sizing in ECS task defs, but container hardening, tuned probes, PDBs or advanced pod-level resilience are missing.
Evidence
tamer98/AWS-ECS-Fargate-ha-CI_CD/ecs_task-definition.tf: ecs task definitions with cpu/memory and awslogs configuration
tamer98/2-Tier-Entry-Tracker_Application/docker-compose.yaml: compose with healthcheck and service dependency
tamer98/AWS-ECS-Fargate-ha-CI_CD/Dockerfile: nginx-based image for the frontend
Observability & Monitoring
2/10
Watching system health
Basic observability pieces exist such as Grafana service and awslogs configuration in ECS tasks, but there is no SLO/alerting, alert routing, Prometheus/Alertmanager or dashboards as code shown.
Reliability & Incident Response
3/10
Keeping systems up
Some reliability-oriented settings are present including multi-AZ networking, ECS deployment health parameters, and CI step that waits for service stability, but there are no runbooks, postmortems, automated rollback gates or chaos/DR rehearsals.
Evidence
tamer98/AWS-ECS-Fargate-ha-CI_CD/vpc.tf: multi-AZ subnets and NAT gateways
tamer98/AWS-ECS-Fargate-ha-CI_CD/ecs_service.tf: desired_count and deployment_minimum_healthy_percent/deployment_maximum_percent
tamer98/AWS-ECS-Fargate-ha-CI_CD/.github/workflows/main.yml: amazon-ecs-deploy-task-definition@v1 with wait-for-service-stability: true
Cloud & Cost Optimization
2/10
Smart use of the cloud
Cloud constructs are used correctly but there is little evidence of cost optimization or autoscaling strategies; architecture contains potentially costly defaults like multiple NAT gateways and single-node EKS managed node group without autoscaling.
Expertise
Cloud Platforms & Architecture• Middle
Infrastructure as Code• Middle
Technologies
Containers
Bash
Terraform
Docker Compose
GitHub Actions
AWS
Kubernetes
Grafana
Amazon EKS
AWS Fargate
Amazon EC2
CI/CD• mentioned only
CI/CD• mentioned only
DevOps• mentioned only
Docker• mentioned only
Python• mentioned only
Recommendations
- Harden CI/CD and releases by introducing reusable workflows, promotion gates and artifact signing or provenance rather than runner-local DinD patterns.
- Add Terraform state locking (DynamoDB) and automated infra tests or plan checks, and formalize multi-environment separation with parameterized modules.
- Improve container hardening and runtime resilience by using non-root users, adding health/readiness probes, PodDisruptionBudgets or equivalent and documented graceful shutdown handling.
- Implement observability as code with Prometheus/Alertmanager SLOs, dashboard-as-code and runbooks tied to alerts to raise operational maturity.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Backend Developer
Confidence: Medium API Engineer
Junior backend Node.js developer who builds small API-driven web prototypes integrating AI and external location services. The strongest proven skill is integrating OpenAI image and chat endpoints with geocoding and MongoDB persistence as implemented in app/index.js and db.js. The codebase lacks production-grade concerns such as robust error handling, testing, input validation, migration history, and secure production deployment patterns.
API Design
3/10
How well APIs are designed
Basic REST endpoints exist and are functional but lack versioning, idempotency, consistent error contracts, pagination, and input validation; routing is single-version and mainly glue logic around external APIs.
Data Layer & Database
2/10
Working with databases
Uses Mongoose schemas and simple persistence but no migration history, no transaction handling, and incorrect async usage (missing awaits) leading to potential consistency issues.
Evidence
tamer98/SmartPath-AI_Application/app/db.js: DataPromptSchema and mongoose.model
tamer98/SmartPath-AI_Application/app/index.js: findDataInDb using DataPrompt.findById without await and saveDataInDb calling data.save() without error handling
tamer98/SmartPath-AI_Application/mongo-init.js: initial DB setup and user creation (single init only)
Scalability & Performance
2/10
Handling load and speed
Minimal performance considerations: Prometheus metrics are exposed but no caching, parallelization of external API calls, queueing, or rate limiting; external API calls are performed sequentially in loops.
System Architecture
2/10
Overall system structure
Monolithic Express app with server-side rendering and duplicated code across folders; folder/module boundaries are simple and pragmatic but there is no evident service decomposition, config segregation, or production-grade deployment artifacts in the analyzed human-authored code.
Security & Auth
2/10
Protecting data and access
Environment variables are used for secrets but there is little input validation, no auth around routes, weak DB initialization shown, and inconsistent env variable naming; basic secrets hygiene exists but security hardening is minimal.
Evidence
tamer98/SmartPath-AI_Application/app/index.js: dotenv usage and direct use of process.env values for API keys
tamer98/SmartPath-AI_Application/mongo-init.js: creates DB user with plaintext weak password 'user_pass' and inserts default admin user
tamer98/SmartPath-AI_Application/app/index.js: user-provided input is split and inserted into prompts and geocoding calls with no sanitization
Reliability & Observability
3/10
Stability and monitoring
Basic observability exists (Prometheus metrics and console logging) but lacks structured logs, correlation ids, graceful shutdown, timeouts, retries with backoff, and incident-oriented telemetry.
Expertise
Backend AI & LLM• Junior
Node.js• Junior
Industries
Travel & Tourism• Junior
Technologies
Python
MySQL
MongoDB• 5y+
Mongoose
ArgoCD• mentioned only
AWS• mentioned only
CI/CD• mentioned only
CI/CD• mentioned only
Cloud• mentioned only
GitHub Actions• mentioned only
GitOps• mentioned only
Grafana• mentioned only
Recommendations
- Assign to build or extend Express-based prototypes that integrate third-party APIs (LLMs, geocoding) and MongoDB-backed views.
- Have them implement and harden a single service: add proper async/await usage, input validation, structured logging, timeouts and retries for external calls.
- Pair them with a senior engineer to convert sequential API calls to resilient patterns (parallelization, rate limiting, circuit breaker) and to implement CI/CD and secure secrets management.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium Fullstack
Full-stack web developer (Junior) focused on small production Node.js apps with frontend pages and AI integration as a core capability. The strongest proven skill is integrating AI and geocoding into an Express/Mongo workflow, evidenced by the OpenAI and OpenCage usage alongside Mongoose schema and route handlers in app/index.js and db.js. The work shows visual polish on static pages but lacks robust async handling, automated tests, production-grade error handling, and accessible custom UI components.
UI Component Architecture
2/10
How interface parts are built
Static HTML/CSS pages and small JS apps are present but there is no deliberate component architecture, reuse patterns, or a custom design system.
Evidence
SmartPath-AI_Application/app/index.html: static page structure with Bootstrap classes
Memory_Cards_Game/index.js: monolithic DOM-manipulating game logic
SmartPath-AI_Application/app/public/style.css: project-specific CSS rather than componentized styles
Responsive & Cross-browser
3/10
Works on all screens and browsers
Basic responsive layout using Bootstrap and viewport meta; standard responsive techniques are applied but there is no evidence of advanced layout strategies or i18n/RTL readiness.
Evidence
SmartPath-AI_Application/app/index.html: bootstrap CDN and responsive grid usage
Smart_Path_Finder-AI/index.html: viewport meta and bootstrap classes
Performance Optimization
2/10
Speed of the interface
Little performance engineering beyond basic observability; Prometheus metrics collection is present but there is no evidence of code-splitting, bundle analysis, virtualization, or measured LCP/INP work.
Evidence
SmartPath-AI_Application/app/index.js: client.collectDefaultMetrics() and /metrics endpoint using prom-client
SmartPath-AI_Application/app/package.json: prom-client listed in dependencies
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility effort observed - images include alt attributes and HTML semantics are basic, but there are no ARIA patterns, focus management, or automated a11y checks.
Evidence
SmartPath-AI_Application/app/index.html: img elements include alt attributes
Memory_Cards_Game/index.html: semantic structure but no ARIA or keyboard handling for custom controls
State Management & Data Flow
2/10
Managing data in the app
Server-state is implemented with Mongoose models and simple save/find flows, but there are async/await misuse patterns and limited error handling or race-condition controls.
Evidence
SmartPath-AI_Application/app/db.js: Mongoose schema and model (DataPrompt)
SmartPath-AI_Application/app/index.js: saveDataInDb and findDataInDb implementations show basic CRUD without await/transaction handling
UX & Visual Polish
3/10
Look and feel quality
Visual polish is present with gradients, animations and Bootstrap styling producing a pleasant UI, but UX patterns like skeletons, loading placeholders, or undo flows are absent.
Evidence
SmartPath-AI_Application/app/public/style.css: gradient animations and UI styling
SmartPath-AI_Application/app/index.html: forms and route selection UI with clear CTAs
Expertise
HTML & CSS• Junior
Frontend AI Integration• Junior
Industries
Travel & Tourism• Junior
Technologies
JavaScript• Junior • 3y+
Node JS• Junior
Next.js
Express
Helm
Prometheus
Azure
CI/CD
Bootstrap
Jenkins
Git
Docker
React.js
Axios
Dotenv
Cheerio
ArgoCD• mentioned only
AWS• mentioned only
CI/CD• mentioned only
CI/CD• mentioned only
Cloud• mentioned only
GitHub Actions• mentioned only
GitOps• mentioned only
Grafana• mentioned only
Recommendations
- Fix async/await correctness and add robust error handling and validation around all external calls (OpenAI, geocoding, DB) to make server flows reliable.
- Add automated tests (unit and integration) for API routes and data layer, and add CI checks to prevent regressions.
- Improve frontend architecture by componentizing UI (for example migrating pages to a small framework or modular templates) and introduce loading states and accessible ARIA patterns for custom widgets.
- Expand observability beyond metrics - add structured logs, request tracing, and handle rate-limit and retry logic when calling external APIs.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: