M. ENGINEERING SYSTEMS
PORTFOLIO / 2026
INITIALIZING 00%
M.
A LITTLE SPACE TO BUILD BIG THINGS

WELCOME.

TO MOMNA'S ENGINEERING WORLD

CLOUD✳ DEVOPS✳ AUTOMATION✳ RELIABILITY✳ KUBERNETES✳ CLOUD✳ DEVOPS✳ AUTOMATION✳ RELIABILITY✳ KUBERNETES✳
SYSTEMS WITH PURPOSE
01 — 06
CASE STUDY / CLOUD & DEVOPS ENGINEERING
MULTI-CLOUD KUBERNETES

One workload.
Two clouds.

Multi-Cloud Kubernetes Deployment — AWS EKS + Azure AKS

Provisioning Kubernetes infrastructure with Terraform and deploying a Dockerized Flask application across Amazon EKS and Azure AKS.

KUBERNETES AWS EKS AZURE AKS TERRAFORM DOCKER GITHUB ACTIONS
DEPLOYMENT ARCHITECTURE 01 — 05
01
GitHub Repository Application source and manifests
02
GitHub Actions + Docker Build and publish container image
03
Terraform Cloud infrastructure as code
04
Amazon EKS + Azure AKS Two managed Kubernetes environments
05
Kubernetes Workload Dockerized Flask application
TARGET
INFRASTRUCTURE + CONTAINERS AWS ↔ AZURE
PROJECT TYPE Multi-Cloud Deployment
APPLICATION Python / Flask
ORCHESTRATION Kubernetes
INFRASTRUCTURE Terraform / EKS / AKS
ENGINEERING REQUIREMENTS MC-01
R01

Provision both clusters

Use separate Terraform configurations to provision Amazon EKS and Azure AKS, keeping each provider's infrastructure resources explicit.

TERRAFORM / IaC
R02

Account for network design

Document the AWS VPC and subnet layout alongside the Azure resource group, virtual network, and AKS subnet.

NETWORKING
R03

Build and distribute the image

The GitHub Actions workflow runs on pushes to main, builds the Docker image, and pushes the latest tag to Docker Hub using repository secrets.

CI / CONTAINERS
R04

Verify deployment in both clouds

Assess how the Kubernetes Deployment and LoadBalancer Service run in EKS and AKS. The checked-in GitHub Actions workflow builds and pushes the image; deploying the Kubernetes manifests is a separate step.

KUBERNETES
REQUIREMENTS TO ASSESS R01 — R04
02 / PROBLEM & REQUIREMENTS
ENGINEERING PROBLEM

Two clouds.One deployment model.

Operating Kubernetes across AWS and Azure introduces separate infrastructure configurations, network boundaries, cluster access requirements, and deployment considerations. The challenge is to document how these parts fit together without assuming both environments are managed by an identical end-to-end automation workflow.

01 PROJECT OBJECTIVE

Explain how Terraform provisions EKS and AKS, how the Dockerized Flask application is packaged and distributed, and how the Kubernetes workload is deployed and verified across both cloud environments. Identify credential, state-management, networking, and operational trade-offs using repository evidence.

PROJECT SCOPE
01 Terraform → EKS / AKS
02 GitHub Actions → Docker Hub
03 Kubernetes → Flask application

03 / ARCHITECTURE & SYSTEM DESIGN

One application. Two cloud platforms.

This project explores deploying a containerized Flask application across AWS EKS and Azure AKS. Terraform configurations define the cloud infrastructure separately, while Kubernetes manifests describe the application workload and service.

CORE TECHNOLOGIES
AWS EKS Azure AKS Kubernetes Terraform Docker GitHub Actions Flask

Multi-cloud architecture

System flow
01

Application repository

Flask application code, Dockerfile and Kubernetes manifests.

SOURCE
02

Image build workflow

GitHub Actions builds the Docker image after a push to main.

CI
03

Container image registry

The workflow pushes the built image to Docker Hub.

DOCKER HUB
04

Cloud infrastructure

Separate Terraform configurations cover AWS and Azure resources.

TERRAFORM
05

Kubernetes workloads

EKS and AKS are the target platforms for the application workload.

EKS / AKS

Infrastructure layer

AWS + AZURE

Terraform configurations are organized separately for AWS and Azure. The repository also includes Kubernetes Deployment and Service manifests. The checked-in GitHub Actions workflow builds and pushes the container image; applying the Kubernetes manifests is a separate deployment step.

↳ This is a conceptual architecture overview, not a claim that one automated pipeline provisions both clusters and deploys the workload. Refer to the repository configurations and deployment evidence for the exact steps completed on each cloud.

04 / IMPLEMENTATION & CORE COMPONENTS

Every component has a job.

The repository separates the Flask application, container packaging, image publishing, cloud-specific Terraform configuration and Kubernetes resources. The checked-in workflow builds and publishes an image; cluster provisioning and applying Kubernetes manifests remain separate operations.

ENGINEERING PRINCIPLE

Keep application code, image publishing, cloud infrastructure and Kubernetes resources independently reviewable. One important integration gap remains: the workflow publishes a `multicloud-app:latest` image, while the checked-in Deployment references `momnashahid/multi-cloud-app:v1`. Align these image references before relying on the workflow for updates.

COMPONENT / 01 Application

Flask application

A Python Flask web application packaged for execution inside a container. Its application source is maintained separately from infrastructure and deployment configuration.

Source: app/app.py
COMPONENT / 02 Packaging

Docker image

The Dockerfile uses Python 3.10 slim, installs application requirements, copies the Flask files and exposes port 5000.

Source: Dockerfile
COMPONENT / 03 Automation

GitHub Actions

On pushes to main, the workflow checks out the repository, authenticates to Docker Hub using configured GitHub secrets, then builds and pushes `${DOCKERHUB_USERNAME}/multicloud-app:latest`. It does not provision clusters or apply Kubernetes manifests.

Source: .github/workflows/ci-cd.yaml
COMPONENT / 04 Infrastructure

Terraform

AWS configuration defines a VPC with public/private subnets, a single NAT gateway and an EKS cluster with a managed node group. Azure configuration defines a resource group, VNet, subnet and AKS cluster with a system-assigned identity.

Source: terraform/aws/ · terraform/azure/
COMPONENT / 05 Orchestration

Kubernetes manifests

The Deployment requests two replicas and references `momnashahid/multi-cloud-app:v1`. The LoadBalancer Service maps port 80 to target port 5000; the image reference currently differs from the image tag published by the workflow.

Source: k8s/deployment.yaml · k8s/service.yaml
COMPONENT / 06 Image registry

Docker Hub

The checked-in workflow pushes `${DOCKERHUB_USERNAME}/multicloud-app:latest`. The Kubernetes Deployment instead references `momnashahid/multi-cloud-app:v1`, so the repository needs a consistent image name/tag or an explicit release step.

Workflow tag: multicloud-app:latest · manifest tag: multi-cloud-app:v1
05 / WORKFLOW & EXECUTION
DELIVERY LIFECYCLE

From code to cloud.

The lifecycle connects the Flask application to container distribution and Kubernetes runtime resources across AWS EKS and Azure AKS. Each stage has a distinct responsibility, from building the image to configuring infrastructure and applying the workload manifests.

EXECUTION PRINCIPLE

A successful image build does not prove a successful cluster deployment. The checked-in GitHub Actions workflow builds and publishes the Docker image; infrastructure provisioning and Kubernetes manifest application remain separate operations.

EXECUTION SEQUENCE 01 — 05
01

Source change

SOURCE

The Flask application, Dockerfile, Terraform configurations and Kubernetes manifests are maintained in the project repository.

GitHub repository
02

Workflow execution

AUTOMATION

A push to the main branch triggers GitHub Actions to run the configured container image workflow.

.github/workflows/
03

Container build

PACKAGING

Docker packages the Flask application and its dependencies into an image using the repository's Dockerfile.

Dockerfile → image
04

Image distribution

REGISTRY

GitHub Actions authenticates to Docker Hub using repository secrets and pushes the image with the latest tag.

Docker image → Docker Hub
05

Cloud deployment

RUNTIME

The separate infrastructure and deployment steps use the AWS EKS or Azure AKS environment and apply the Kubernetes Deployment and Service manifests.

Terraform → EKS / AKS → Kubernetes
EXPECTED OUTCOME

Containerized workload running in the target cluster

VERIFY THE DEPLOYMENT

From workflow to running application.

A multi-cloud deployment needs evidence beyond configuration files. These project artifacts document the container workflow, application execution in both cloud environments, and the Kubernetes contexts used for the setup.

01

Workflow execution

The pipeline screenshot documents the GitHub Actions workflow. The configured workflow builds and pushes the Docker image; it does not itself deploy the Kubernetes manifests.

02

Application execution

Separate screenshots show the application running on the AWS and Azure Kubernetes clusters, documenting application execution in both environments.

03

Multi-cloud context

The Kubernetes contexts screenshot documents the multi-cloud cluster setup. Together, these artifacts support the project's cross-cloud deployment story.

Evidence-led validation Each artifact supports a specific part of the project. Workflow completion, application execution and cluster context are different forms of evidence and should not be treated as interchangeable proof.

ENGINEERING RESPONSIBLY

Reliable delivery. Responsible infrastructure.

Running Kubernetes across AWS EKS and Azure AKS introduces several operational boundaries: registry credentials, externally exposed services, workflow failures and infrastructure changes. These areas need deliberate review without assuming controls that have not been verified.

CORE PRINCIPLE

Keep credentials out of source code, review network exposure, inspect failures before retrying, and validate infrastructure changes before applying them.

RELIABILITY REVIEW 04 / FOCUS AREAS
01
ACCESS CONTROL

Registry Credentials

The GitHub Actions workflow authenticates to Docker Hub using GitHub repository secrets. Secret values should remain outside committed source files and must not be printed in workflow logs.

PROTECT SENSITIVE VALUES
02
NETWORK BOUNDARIES

LoadBalancer Exposure

The Kubernetes Service uses type LoadBalancer and maps external port 80 to container port 5000. Review the resulting public exposure and the relevant cloud network rules for each cluster.

REVIEW SERVICE ACCESS
03
FAILURE VISIBILITY

Workflow Feedback

GitHub Actions provides run status and job logs for investigating image build or publishing failures. A successful image workflow alone does not prove that the Kubernetes workload was deployed successfully.

INSPECT BEFORE RETRYING
04
INFRASTRUCTURE STATE

Terraform & Change Review

AWS and Azure infrastructure are organized in separate Terraform directories. Review the intended resource changes and resulting infrastructure before applying changes to either cloud environment.

REVIEW CHANGES AND OUTPUT

Verification boundary

These are the security and reliability considerations relevant to this stack, not a claim that every control has been implemented or independently tested. The checked-in workflow builds and pushes the container image; Kubernetes deployment is a separate operation. Automated rollback, a dedicated monitoring system and a comprehensive security audit are not claimed here.

ENGINEERING ANALYSIS / 08

Technology decision matrix

04 COMPONENTS
CONTAINER DELIVERY WORKFLOW
01 GitHub Push to main
02 Actions Build image
03 Docker Hub Push image
SEPARATE INFRASTRUCTURE LIFECYCLE

AWS and Azure have separate Terraform configurations. The checked-in workflow only builds and pushes an image; it does not provision clusters or apply Kubernetes manifests. The workflow publishes multicloud-app:latest, while the Kubernetes manifest references multi-cloud-app:v1 — these tags do not match.

CLOUD / 01

AWS EKS

VPC across two AZs; private EKS subnets; one NAT gateway; managed node group (1–2 t3.medium nodes).

CLOUD / 02

Azure AKS

East US VNet and AKS subnet; one-node pool using Standard_DC2as_v5; Azure CNI and Standard Load Balancer.

TECHNOLOGY ENGINEERING VALUE TRADE-OFF
01 Terraform

Codified, provider-specific AWS and Azure infrastructure.

No remote backend is defined in the checked-in configs, so Terraform defaults to local state; shared locking and recovery are not configured here.

02 Kubernetes

Deployment requests two app replicas; LoadBalancer Service maps port 80 to container port 5000.

Each cloud still needs its own cluster access and networking. No cross-cloud VPN or peering is defined in the repo.

03 Docker + Hub

A shared registry distributes the container image to Kubernetes environments.

Tag mismatch: Actions pushes multicloud-app:latest, while the manifest uses multi-cloud-app:v1.

04 GitHub Actions

Automated image building and publishing when code is pushed to main.

Workflow maintenance; Kubernetes deployment remains a separate step.

DESIGN IMPLICATION

A shared container and Kubernetes resource model reduce application packaging differences, but cloud infrastructure, credentials, networking, cost and operations remain provider-specific. The image-tag mismatch and separate deployment steps must be resolved before treating this as an end-to-end automated delivery pipeline.

SYSTEM DESIGN TRADE-OFFS

One application. Two cloud environments.

This project combines Terraform-managed infrastructure, a Dockerized Flask application, Kubernetes manifests and a GitHub Actions image workflow. The engineering challenge is not just using both clouds; it is understanding which responsibilities are shared and which remain provider-specific.

A

Infrastructure as Code

Separate AWS and Azure configurations make infrastructure reviewable. Neither checked-in config defines a remote backend, so Terraform uses local state by default; remote locking and shared-state recovery are not configured here. The Azure kube-config output is marked sensitive, but that does not encrypt or secure the state file itself.

B

Automation has a boundary

GitHub Actions automates the Docker image build and push. Terraform provisioning and applying Kubernetes manifests are separate operations, not one end-to-end deployment pipeline in the checked-in workflow.

C

Cost and operational ownership

Two managed clusters mean separate control-plane, worker, load-balancer and operational costs. AWS also configures one NAT gateway: this can cost less than one per AZ, but creates an egress availability bottleneck. The repo defines no cross-cloud network link, and provider credentials are not hardcoded in the Terraform files.

09 / RESULTS & REFLECTION MULTI-CLOUD DELIVERY REVIEW

What the project demonstrates.

The repository combines separate Terraform configurations for AWS EKS and Azure AKS, a Dockerized Flask application, Kubernetes manifests and a GitHub Actions image-publishing workflow. Screenshots document application execution in both clusters; the checked-in workflow does not automate the full deployment.

∴

Engineering takeaway A shared application image and Kubernetes resource model support portability, but reliable delivery also depends on matching image tags, secure access, state management, networking and tested recovery procedures.

AWS EKS AZURE AKS DOCKER TERRAFORM KUBERNETES GITHUB ACTIONS
DELIVERY EVIDENCE

Documented project outcomes

04 ITEMS
01
CLOUD INFRASTRUCTURE

AWS EKS and Azure AKS configuration

The AWS configuration defines a VPC across two Availability Zones, private and public subnets, one NAT gateway and an EKS cluster. The Azure configuration defines a VNet, subnet and AKS cluster with a system-assigned managed identity.

IN REPO
02
CONTAINER DELIVERY

Docker image workflow

On pushes to main, the workflow builds and pushes the :latest image to Docker Hub. The Kubernetes manifest instead references momnashahid/multi-cloud-app:v1, so the published and deployed image references do not match.

IN REPO
03
KUBERNETES RESOURCES

Deployment and LoadBalancer Service

The manifest requests two application replicas and a LoadBalancer Service mapping port 80 to target port 5000. This is configuration evidence, not proof of autoscaling or high availability under failure.

IN REPO
04
APPLICATION EXECUTION

Application shown in both clouds

Repository screenshots document the Flask application running on the AWS and Azure Kubernetes clusters, alongside evidence of configured Kubernetes contexts.

SCREENSHOTS
ENGINEERING REVIEW / 03

Lessons & next improvements

L01

Infrastructure reproducibility

Keep provider-specific Terraform configurations version-controlled. Both checked-in configurations lack a remote backend block, so Terraform defaults to local state unless configured separately; team state sharing and locking are not defined.

L02

Credential and network security

Keep Docker Hub credentials in GitHub Actions secrets and review cloud permissions and LoadBalancer exposure. Cloud provider credentials are not hardcoded in the Terraform files; the actual authentication method depends on the environment.

L03

Deployment and recovery

Add a deployment stage only after aligning the workflow image name and tag with the Kubernetes manifest. Then add validation gates and test recovery; the current workflow only builds and pushes the image.

L04

Observability and cost

Add health checks, monitoring and alerting, then measure costs. AWS uses one NAT gateway, which reduces NAT gateway count but can create an availability bottleneck; both clusters and their networking resources add ongoing cost.

04 / IMPLEMENTATION & CORE COMPONENTS

Every component has a job.

The repository separates the Flask application, container packaging, image publishing, cloud-specific Terraform configuration and Kubernetes resources. The checked-in workflow builds and publishes an image; cluster provisioning and applying Kubernetes manifests remain separate operations.

ENGINEERING PRINCIPLE

Keep application code, image publishing, cloud infrastructure and Kubernetes resources independently reviewable. One important integration gap remains: the workflow publishes a `multicloud-app:latest` image, while the checked-in Deployment references `momnashahid/multi-cloud-app:v1`. Align these image references before relying on the workflow for updates.

COMPONENT / 01 Application

Flask application

A Python Flask web application packaged for execution inside a container. Its application source is maintained separately from infrastructure and deployment configuration.

Source: app/app.py
COMPONENT / 02 Packaging

Docker image

The Dockerfile uses Python 3.10 slim, installs application requirements, copies the Flask files and exposes port 5000.

Source: Dockerfile
COMPONENT / 03 Automation

GitHub Actions

On pushes to main, the workflow checks out the repository, authenticates to Docker Hub using configured GitHub secrets, then builds and pushes `${DOCKERHUB_USERNAME}/multicloud-app:latest`. It does not provision clusters or apply Kubernetes manifests.

Source: .github/workflows/ci-cd.yaml
COMPONENT / 04 Infrastructure

Terraform

AWS configuration defines a VPC with public/private subnets, a single NAT gateway and an EKS cluster with a managed node group. Azure configuration defines a resource group, VNet, subnet and AKS cluster with a system-assigned identity.

Source: terraform/aws/ · terraform/azure/
COMPONENT / 05 Orchestration

Kubernetes manifests

The Deployment requests two replicas and references `momnashahid/multi-cloud-app:v1`. The LoadBalancer Service maps port 80 to target port 5000; the image reference currently differs from the image tag published by the workflow.

Source: k8s/deployment.yaml · k8s/service.yaml
COMPONENT / 06 Image registry

Docker Hub

The checked-in workflow pushes `${DOCKERHUB_USERNAME}/multicloud-app:latest`. The Kubernetes Deployment instead references `momnashahid/multi-cloud-app:v1`, so the repository needs a consistent image name/tag or an explicit release step.

Workflow tag: multicloud-app:latest · manifest tag: multi-cloud-app:v1
PROJECT REPOSITORY SOURCE CODE
MOMNA-SHAHID17 /

multi-cloud-kubernetes-deployment

Multi-Cloud Kubernetes Deployment using AWS EKS, Azure AKS, Terraform, Docker, Kubernetes and GitHub Actions. The workflow publishes the image; cluster provisioning and manifest application are separate steps in the checked-in implementation.

Explore source repository
REPOSITORY STRUCTURE SOURCE MAP
▾ multi-cloud-kubernetes-deployment/
├─ ▰ .github/workflows/ Build & push image
├─ ▰ app/ Flask application
├─ ▰ k8s/ Deployment & Service
├─ ▰ terraform/aws/ AWS infrastructure
├─ ▰ terraform/azure/ Azure infrastructure
├─ ▤ Dockerfile Container build
└─ ▤ README.md Project documentation

Selected paths from the repository. Visit GitHub for the complete file tree and current implementation.

TECHNOLOGY INDEX
AWS EKS Azure AKS Terraform Kubernetes Docker Docker Hub GitHub Actions Flask / Python
Inspect the implementation Source code, infrastructure and documentation
PROJECT HANDOFF

Two clouds. One documented project.

The repository brings together the Flask application, Docker image definition, GitHub Actions workflow, Kubernetes manifests and separate Terraform configurations for AWS and Azure. Review the code alongside the available implementation evidence to understand the multi-cloud approach and its current boundaries. The workflow publishes `multicloud-app:latest`, while the Kubernetes Deployment references `momnashahid/multi-cloud-app:v1`; align these image references before treating image publishing as an update path.

01

Trace the image workflow

Inspect how GitHub Actions builds the Docker image and pushes it to Docker Hub when changes are pushed to main.

02

Compare infrastructure configurations

Explore the AWS and Azure Terraform directories. The checked-in configurations do not define a remote state backend, so Terraform uses local state by default unless configured elsewhere.

03

Connect code with evidence

Review the pipeline, cluster application screenshots and Kubernetes contexts alongside the repository documentation.

POTENTIAL NEXT ITERATIONS
+

Align the Docker image name and tag used by GitHub Actions and the Kubernetes Deployment, then add a validated deployment step.

+

Configure and protect Terraform state with an appropriate remote backend and locking, then document recovery procedures.

+

Evaluate resource scaling, monitoring, cloud costs and security controls.

These are potential improvements, not claims that the capabilities are already implemented. The checked-in workflow only builds and pushes the image; it does not provision EKS/AKS or apply Kubernetes manifests. The workflow image tag also differs from the image in the Deployment. No cross-cloud network connection or remote Terraform state backend is defined in the checked-in Terraform configuration.

Scroll to Top