Shaheer Ahmad
DevOps Engineer
5+ years exp
Management: 1-2 years (1-5 people)
Bash
Active 3 days ago
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Kubernetes-focused platform engineer (middle level) with practical experience writing manifests and basic Terraform-managed Kubernetes resources for microservice deployments. The strongest proven skill is Kubernetes orchestration and hardening patterns as shown by kustomize/manifests/api.yaml, kustomize/manifests/metrics-server.yaml and swagger-ui-k8s/statefulset.yaml that include probes, HPA, resource quotas, PV/PVC and a non-root securityContext. There is little to no evidence of production-grade CI/CD pipelines, remote Terraform state and locking, infra testing, SLO-driven alerting or secrets management tools in the public artifacts.
Phone
Technical skills
Languages
1
Bash
DevOps
24
AWS
Kubernetes
Grafana
Docker
Amazon S3
GitHub Actions
Ansible
Google GKE
Amazon CloudWatch
API Gateway
ArgoCD
Prometheus
Azure AKS
Nginx
Helm
Terraform
Bamboo
WebSockets
Uptime Kuma
Azure
GCP
Amazon EC2
Amazon EKS
GitHub
Cybersecurity
4
SonarQube
AWS WAF
Kyverno
Trivy
Databases
8
Redis
PostgreSQL
MySQL
Oracle
Amazon Aurora
Azure Cosmos DB
DynamoDB
MS SQL
Other
22
React.js
Postman
OpenAI
Metal
Akamai
GitLab
GitLab CI
Linux
IAM
Karpenter
KEDA
Bitbucket
CI/CD
GitOps
HAProxy
Jenkins
IaC
Containers
Observability
DNS
Shift-Left
Shift-Left Security
Timeline
Senior DevOps Engineer
•
Senior
Maybank
•
Full-Time
Contributed to Maybank’s Digital Stand-In initiative by modernizing legacy systems into AWS-based cloud-native infrastructure. Built a modular Terraform framework and deployed containerized Spring Boot and Node.js services on Amazon EKS. Implemented Kubernetes security and shift-left checks with Kyverno, Trivy, AWS Inspector, and SonarQube, and delivered GitOps deployments via Argo CD. Automated Confluent Kafka KRaft operations and supported database modernization toward Amazon RDS with AWS DMS/SCT.
Terraform
Ansible
GitHub Actions
Amazon S3
IAM
Amazon CloudWatch
AWS WAF
API Gateway
ArgoCD
Kubernetes
Docker
Trivy
SonarQube
Kyverno
Karpenter
KEDA
Apache Kafka
AWS
Senior DevOps Engineer
•
Senior
Hutfin Inc
•
Full-Time
Built secure multi-cloud CI/CD pipelines using GitHub Actions with self-hosted runners for Kubernetes on EKS and AKS. Reduced deployment time while improving cluster security by privatizing Kubernetes API access. Implemented API Gateway integrations with VPC Link and private load balancing, containerized services with multi-stage Docker builds, and strengthened security using AWS WAF and vulnerability scanning. Developed observability with CloudWatch and Uptime Kuma, integrated Azure Search and OpenAI workflows, and supported AWS WebSockets-based real-time messaging.
GitHub Actions
Docker
Kubernetes
Azure AKS
AWS
API Gateway
AWS WAF
Amazon S3
Amazon CloudWatch
Uptime Kuma
OpenAI
WebSockets
Senior DevOps Engineer
•
Senior
Devsinc
•
Full-Time
Modernized monolithic applications into microservices and automated recurring operations using Kubernetes CronJobs on GKE. Containerized applications with Docker and enabled GitOps delivery with Argo CD on GKE. Standardized Kubernetes deployments with Helm charts and added basic observability using Uptime Kuma to improve workload visibility.
Kubernetes
Google GKE
Docker
ArgoCD
Helm
Uptime Kuma
DevOps Engineer
•
Middle
Vaival Technologies
•
Full-Time
Built and operated on-prem bare-metal infrastructure with a focus on high availability and scalable system operations. Implemented CI/CD pipelines with Bamboo and added automated quality checks using SonarQube. Deployed multi-master/multi-worker Kubernetes clusters on bare metal using Ansible, and set up monitoring with Prometheus and Grafana for Redis, Nginx, and Nginx Ingress.
Bamboo
SonarQube
Ansible
Kubernetes
Prometheus
Grafana
Redis
Nginx
Associate DevOps Engineer
•
Middle
12iD
•
Full-Time
Created AWS deployment pipelines with CodePipeline to automate releases of React.js and Node.js applications on EC2 and Elastic Beanstalk. Performed API testing and validation using Postman to support functional and integration testing. Carried out manual web and mobile testing and resolved reported issues during sprint cycles.
AWS
Postman
React.js
Node JS
University of Engineering and Technology, Peshawar
Bachelor's Degree •
Computer Systems Engineering
Middle DevOps Engineer
Confidence: Medium Platform SRE
Kubernetes-focused platform engineer (middle level) with practical experience writing manifests and basic Terraform-managed Kubernetes resources for microservice deployments. The strongest proven skill is Kubernetes orchestration and hardening patterns as shown by kustomize/manifests/api.yaml, kustomize/manifests/metrics-server.yaml and swagger-ui-k8s/statefulset.yaml that include probes, HPA, resource quotas, PV/PVC and a non-root securityContext. There is little to no evidence of production-grade CI/CD pipelines, remote Terraform state and locking, infra testing, SLO-driven alerting or secrets management tools in the public artifacts.
CI/CD Pipelines
2/10
Automated build and deploy
Minimal CD artifacts; ArgoCD notification config exists but there are no CI/CD pipelines, reusable workflows, deploy gates or rollback steps.
Evidence
argocd/configmaps.yaml
argocd/ingress.yaml
Infrastructure as Code
2/10
Managing servers with code
Basic IaC use is present via Terraform-managed Kubernetes resources but there are no versioned modules, remote state/locking, environment separation or infra tests.
Evidence
application-deployment-using-terraform/deployments.tf
Containerization & Orchestration
3/10
Working with containers
Concrete Kubernetes orchestration skills are shown - multi-kind manifests, StatefulSet with initContainer, PV/PVC, HPA, probes, resource requests and a non-root securityContext - but advanced production patterns like PDBs, affinity/topology spread, immutable image tagging and operators are missing.
Evidence
kustomize/manifests/api.yaml
kustomize/manifests/metrics-server.yaml
swagger-ui-k8s/statefulset.yaml
Observability & Monitoring
2/10
Watching system health
Lightweight observability is present via metrics-server and ArgoCD notifications but there are no alerting rules, dashboards as code, SLOs or structured tracing shown.
Evidence
kustomize/manifests/metrics-server.yaml
argocd/configmaps.yaml
Reliability & Incident Response
2/10
Keeping systems up
Basic reliability hygiene exists - readiness and liveness probes, HPA and resource quotas - but there are no runbooks, postmortems, progressive delivery strategies or explicit rollback criteria.
Evidence
kustomize/manifests/api.yaml
kustomize/manifests/quotes.yaml
Cloud & Cost Optimization
2/10
Smart use of the cloud
Some cost-awareness via resource requests, resource quotas and HPA is evident but there is no rightsizing data, spot/eviction strategies, IAM/workload-identity patterns or measurable cost optimization.
Evidence
kustomize/manifests/api.yaml
kustomize/manifests/frontend.yaml
Expertise
Kubernetes Ecosystem• Middle
Infrastructure as Code• Middle
GitOps & Continuous Delivery• Middle
Technologies
Containers
IaC
Observability
GitOps
ArgoCD• since 2022
Kustomize• mentioned only
minikube• mentioned only
Terraform• mentioned only
Recommendations
- Own Kubernetes manifest hardening and progressive delivery work such as introducing PDBs, affinity/topology spread and non-latest immutable image tagging.
- Build GitOps pipelines and deploy gates with ArgoCD and add explicit rollback criteria and promotion gating.
- Mature Terraform usage by adding versioned modules, remote state with locking and environment separation plus basic infra tests (terratest or conftest).
- Implement observability and SLO-driven alerting including Prometheus alert rules, dashboards as code and incident runbooks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Intern Backend Developer
Confidence: Low Platform Engineer
A junior platform-focused engineer (early-career) who shows practical focus on containerizing Java build and runtime artifacts. The strongest proven skill is creating a multi-stage Docker build to produce a compact runtime image, evidenced by the multi-stage Dockerfile present in the files. There is no public evidence of API design, database schema work, distributed systems patterns, or observability and reliability engineering beyond basic image selection.
API Design
How well APIs are designed
Not evidenced in public code
Data Layer & Database
Working with databases
Not evidenced in public code
Scalability & Performance
2/10
Handling load and speed
Minor build-time optimization evidence via a multi-stage Docker build that reduces final image size; no runtime scaling, caching, queueing or measured performance work.
System Architecture
1/10
Overall system structure
Basic containerization practice visible but no service decomposition, config/secret management, or inter-service contracts to evidence deliberate system architecture decisions.
Security & Auth
1/10
Protecting data and access
Small surface-level security hygiene in image choice and multi-stage builds to avoid shipping build tools; no evidence of auth, secret handling, input validation or dependency audits.
Reliability & Observability
Stability and monitoring
Not evidenced in public code
Recommendations
- Work on CI/CD and container build pipelines for Java applications, extending multi-stage builds with build cache layers and image tagging strategies.
- Improve platform hardening by adding image scanning, dependency audits, and secrets handling patterns for containerized apps.
- Develop basic observability and reliability features such as structured logging, health checks, and graceful shutdown handling in containerized services.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Intern Frontend Developer
Confidence: Low Generalist
A junior infrastructure-focused DevOps engineer specializing in Kubernetes and AWS deployment automation. The strongest proven skill is producing step-by-step Kubernetes and AWS deployment guides and runbooks for EKS, API Gateway VPC Link, and ingress controller setups as shown in the deployment documentation artifacts. There is no human-authored application code, frontend components, tests, or CI pipeline code present to evaluate deeper software engineering or frontend expertise.
UI Component Architecture
How interface parts are built
Not evidenced in public code
Responsive & Cross-browser
Works on all screens and browsers
Not evidenced in public code
Performance Optimization
Speed of the interface
Not evidenced in public code
Accessibility & Semantics
Usable for everyone
Not evidenced in public code
State Management & Data Flow
Managing data in the app
Not evidenced in public code
UX & Visual Polish
Look and feel quality
Not evidenced in public code
Industries
Information Technology• Intern
Technologies
AWS• since 2019
Nginx• since 2021
React.js• since 2019
Amazon EKS
ArgoCD• mentioned only
UI• mentioned only
Recommendations
- Author human-readable, human-authored Kubernetes manifests and Helm charts with clear ownership and examples so reviewers can evaluate architecture decisions.
- Contribute concrete IaC modules (Terraform/CloudFormation) or automated CI/CD pipelines (GitHub Actions / GitLab CI) to demonstrate system design and reproducible deployments.
- Add runnable examples and small automation scripts (deployment, rollback, health checks) with tests to show operational reliability and edge-case handling.
- Include at least one application-level repository with source code (service + helm/chart) to demonstrate end-to-end integration and coding practices.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: