Containerisation & Orchestration

Docker containerisation of existing applications — writing optimised Dockerfiles, building multi-stage images, minimising image size, implementing security best practices and ensuring the container runs identically in development, CI and production.

• Dockerfile authoring for PHP, Node.js, Python and Go applications
• Multi-stage build: separate build and runtime stages for smaller images
• Base image selection: official slim or distroless images
• Non-root user execution for security
• Layer caching optimisation to speed up builds
• Image size reduction: remove development dependencies from runtime image
• .dockerignore configuration to exclude unnecessary files
• Image vulnerability scanning with Trivy or Snyk

Docker Compose configuration for local development environments — defining all services (application, database, cache, queue) in a single compose file so every developer starts a consistent, production-like stack with one command, without manual dependency installation.

• docker-compose.yml defining all application services
• Application, database, cache (Redis) and queue (RabbitMQ/SQS local)
• Volume mounts for hot-reload in development
• Environment variable file (.env) integration
• Service dependency ordering: database starts before application
• Named volumes for persistent development data
• Override file: docker-compose.override.yml for developer-specific settings
• Docker Compose profiles for optional services

Kubernetes deployment for applications that need auto-scaling, self-healing and zero-downtime deployments — configuring deployments, services, ingress, persistent volumes and horizontal pod autoscaling on managed Kubernetes (EKS, GKE, AKS or Hetzner k3s).

• Deployment manifest: replicas, resource requests and limits
• Service definition: ClusterIP for internal, LoadBalancer for external
• Ingress configuration with TLS termination
• Horizontal Pod Autoscaler (HPA) based on CPU and memory
• Persistent Volume Claims for stateful workloads
• ConfigMap and Secret management
• Namespace isolation per application and environment
• Helm chart packaging for repeatable deployment

Containerisation and orchestration support for microservices architectures — deploying multiple services independently, managing inter-service communication, implementing service discovery and configuring the networking and observability that microservices require.

• Independent container per microservice
• Service discovery via Kubernetes DNS or service mesh
• API gateway or ingress controller for external traffic routing
• Inter-service communication: REST, gRPC or message queue
• Circuit breaker pattern for service resilience
• Distributed tracing with Jaeger or Zipkin
• Centralised log aggregation across all services
• Independent deployment pipeline per service

Container image registry setup and management — storing, versioning and securing Docker images, with access control, vulnerability scanning, image retention policies and integration with the CI/CD pipeline for automated push on build.

• Registry setup: ECR, GCR, GHCR, GitLab Registry or Docker Hub
• Image tag convention: git SHA, semver and latest
• Automated push from CI pipeline on successful build
• Image vulnerability scanning at push time
• Access control: who can push and pull per repository
• Image retention policy: clean up old tags to control storage costs
• Private registry for internal images not exposed publicly
• Multi-architecture image support: amd64 and arm64

Auto-scaling configuration that matches compute capacity to traffic demand — scaling out during peak load and scaling in during quiet periods to control costs, with warm-up periods, scale-in protection and tested scaling behaviour before go-live.

• Horizontal Pod Autoscaler: scale pods based on CPU and memory
• KEDA (Kubernetes Event-Driven Autoscaling) for queue-based scaling
• Cluster Autoscaler: add nodes when pods cannot be scheduled
• Scale-in protection for pods processing active requests
• Minimum and maximum replica limits to prevent under- and over-scaling
• Scale-out speed: fast response to traffic spike
• Scale-in delay: cool-down period before removing capacity
• Auto-scaling test: load test to verify scaling behaviour before production