diff --git a/.evergreen-functions.yml b/.evergreen-functions.yml
index c004dd098..05e5557cb 100644
--- a/.evergreen-functions.yml
+++ b/.evergreen-functions.yml
@@ -51,10 +51,22 @@ functions:
 
   ### Setup Functions ###
 
+  setup_jq: &setup_jq
+    command: subprocess.exec
+    type: setup
+    params:
+      <<: *e2e_include_expansions_in_env
+      add_to_path:
+        - ${workdir}/bin
+      working_dir: src/github.com/mongodb/mongodb-kubernetes
+      binary: scripts/evergreen/setup_jq.sh
+
   setup_context: &setup_context # Running the first switch is important to fill the workdir and other important initial env vars
     command: shell.exec
     type: setup
     params:
+      add_to_path:
+        - ${workdir}/bin
       shell: bash
       working_dir: src/github.com/mongodb/mongodb-kubernetes
       <<: *e2e_include_expansions_in_env
@@ -103,6 +115,7 @@ functions:
       type: setup
       params:
         command: "git config --global user.email 'kubernetes-hosted-team@mongodb.com'"
+    - *setup_jq # we need jq in the context
     - *setup_context
 
   setup_kubectl: &setup_kubectl
@@ -112,13 +125,6 @@ functions:
       working_dir: src/github.com/mongodb/mongodb-kubernetes
       binary: scripts/evergreen/setup_kubectl.sh
 
-  setup_jq: &setup_jq
-    command: subprocess.exec
-    type: setup
-    params:
-      working_dir: src/github.com/mongodb/mongodb-kubernetes
-      binary: scripts/evergreen/setup_jq.sh
-
   setup_shellcheck:
     command: subprocess.exec
     type: setup
@@ -261,6 +267,18 @@ functions:
     - *setup_evg_host
     - *python_venv
 
+  # This differs for normal evg_host as we require minikube instead of kind for
+  # IBM machines and install aws cli via pip instead
+  setup_building_host_minikube:
+    - *switch_context
+    - command: subprocess.exec
+      type: setup
+      params:
+        working_dir: src/github.com/mongodb/mongodb-kubernetes
+        add_to_path:
+          - ${workdir}/bin
+        command: scripts/evergreen/setup_minikube_host.sh
+
   prune_docker_resources:
     - command: subprocess.exec
       type: setup
@@ -327,8 +345,7 @@ functions:
         shell: bash
         working_dir: src/github.com/mongodb/mongodb-kubernetes
         script: |
-          source .generated/context.export.env
-          scripts/evergreen/e2e/setup_cloud_qa.py create
+          scripts/evergreen/run_python.sh scripts/evergreen/e2e/setup_cloud_qa.py create
     # The additional switch is needed, since we now have created the needed OM exports.
     - *switch_context
 
@@ -339,8 +356,7 @@ functions:
         shell: bash
         working_dir: src/github.com/mongodb/mongodb-kubernetes
         script: |
-          source .generated/context.export.env
-          scripts/evergreen/e2e/setup_cloud_qa.py delete
+          scripts/evergreen/run_python.sh scripts/evergreen/e2e/setup_cloud_qa.py delete
 
   dump_diagnostic_information_from_all_namespaces:
     - command: subprocess.exec
diff --git a/.evergreen.yml b/.evergreen.yml
index 209bf152a..d2e5def80 100644
--- a/.evergreen.yml
+++ b/.evergreen.yml
@@ -77,6 +77,12 @@ variables:
       - func: download_kube_tools
       - func: setup_building_host
 
+  - &setup_group_ibm
+    setup_group_can_fail_task: true
+    setup_group:
+      - func: clone
+      - func: setup_building_host_minikube
+
   - &setup_group_multi_cluster
     setup_group_can_fail_task: true
     setup_group:
@@ -134,7 +140,7 @@ variables:
 
   - &teardown_group
     teardown_group:
-      - func: prune_docker_resources
+      - func: teardown_kubernetes_environment
       - func: run_retry_script
 
   - &base_om7_dependency
@@ -1188,6 +1194,22 @@ task_groups:
       - e2e_om_ops_manager_backup
     <<: *teardown_group
 
+  - name: e2e_smoke_arm_task_group
+    max_hosts: -1
+    <<: *setup_group
+    <<: *setup_and_teardown_task_cloudqa
+    tasks:
+      - e2e_replica_set
+    <<: *teardown_group
+
+  - name: e2e_smoke_ibm_task_group
+    max_hosts: -1
+    <<: *setup_group_ibm
+    <<: *setup_and_teardown_task_cloudqa
+    tasks:
+      - e2e_replica_set
+    <<: *teardown_group
+
   - name: e2e_ops_manager_kind_5_0_only_task_group
     max_hosts: -1
     <<: *setup_group
@@ -1453,6 +1475,42 @@ buildvariants:
     tasks:
       - name: e2e_smoke_task_group
 
+  - name: e2e_smoke_ibm_power
+    display_name: e2e_smoke_ibm_power
+    tags: [ "e2e_test_suite", "e2e_smoke_release_test_suite" ]
+    run_on:
+      - rhel9-power-large
+    allowed_requesters: [ "patch", "github_tag" ]
+#    depends_on:
+#      - name: build_test_image
+#        variant: init_test_run
+    tasks:
+      - name: e2e_smoke_ibm_task_group
+
+  - name: e2e_smoke_ibm_z
+    display_name: e2e_smoke_ibm_z
+    tags: [ "e2e_test_suite", "e2e_smoke_release_test_suite" ]
+    run_on:
+      - rhel9-zseries-small
+    allowed_requesters: [ "patch", "github_tag" ]
+#    depends_on:
+#      - name: build_test_image
+#        variant: init_test_run
+    tasks:
+      - name: e2e_smoke_ibm_task_group
+
+  - name: e2e_smoke_arm
+    display_name: e2e_smoke_arm
+    tags: [ "e2e_test_suite", "e2e_smoke_release_test_suite" ]
+    run_on:
+      - ubuntu2204-arm64-large
+    allowed_requesters: [ "patch", "github_tag" ]
+#    depends_on:
+#      - name: build_test_image
+#        variant: init_test_run
+    tasks:
+      - name: e2e_smoke_arm_task_group
+
   - name: e2e_static_smoke
     display_name: e2e_static_smoke
     tags: [ "e2e_test_suite", "e2e_smoke_release_test_suite" ]
diff --git a/README.md b/README.md
index e230cf351..1f5a59a10 100644
--- a/README.md
+++ b/README.md
@@ -57,4 +57,3 @@ Migration from [MongoDB Community Operator](https://github.com/mongodb/mongodb-k
 See our detailed migration guides:
 - [Migrating from MongoDB Community Operator](docs/migration/community-operator-migration.md)
 - [Migrating from MongoDB Enterprise Kubernetes Operator](https://www.mongodb.com/docs/kubernetes/current/tutorial/migrate-to-mck/)
-
diff --git a/docker/mongodb-agent-non-matrix/Dockerfile b/docker/mongodb-agent-non-matrix/Dockerfile
index dadfc7099..52f448b1d 100644
--- a/docker/mongodb-agent-non-matrix/Dockerfile
+++ b/docker/mongodb-agent-non-matrix/Dockerfile
@@ -1,26 +1,40 @@
-FROM scratch AS base
+FROM scratch AS tools_downloader
 
-ARG agent_version
-ARG agent_distro
-ARG tools_version
-ARG tools_distro
+ARG mongodb_tools_url
 
-ADD https://mciuploads.s3.amazonaws.com/mms-automation/mongodb-mms-build-agent/builds/automation-agent/prod/mongodb-mms-automation-agent-${agent_version}.${agent_distro}.tar.gz /data/mongodb-agent.tar.gz
-ADD https://downloads.mongodb.org/tools/db/mongodb-database-tools-${tools_distro}-${tools_version}.tgz /data/mongodb-tools.tgz
+ARG mongodb_tools_version_amd64
+ADD "${mongodb_tools_url}/${mongodb_tools_version_amd64}" /data/amd64/mongodb_tools.tgz
 
-COPY ./docker/mongodb-kubernetes-init-database/content/LICENSE /data/LICENSE
+ARG mongodb_tools_version_arm64
+ADD "${mongodb_tools_url}/${mongodb_tools_version_arm64}" /data/arm64/mongodb_tools.tgz
 
-FROM registry.access.redhat.com/ubi9/ubi-minimal
+ARG mongodb_tools_version_s390x
+ADD "${mongodb_tools_url}/${mongodb_tools_version_s390x}" /data/s390x/mongodb_tools.tgz
 
-ARG version
+ARG mongodb_tools_version_ppc64le
+ADD "${mongodb_tools_url}/${mongodb_tools_version_ppc64le}" /data/ppc64le/mongodb_tools.tgz
 
-LABEL name="MongoDB Agent" \
-      version="${version}" \
-      summary="MongoDB Agent" \
-      description="MongoDB Agent" \
-      vendor="MongoDB" \
-      release="1" \
-      maintainer="support@mongodb.com"
+FROM scratch AS agent_downloader
+
+ARG mongodb_agent_url
+
+ARG mongodb_agent_version_amd64
+ADD "${mongodb_agent_url}/${mongodb_agent_version_amd64}" /data/amd64/mongodb_agent.tgz
+
+ARG mongodb_agent_version_arm64
+ADD "${mongodb_agent_url}/${mongodb_agent_version_arm64}" /data/arm64/mongodb_agent.tgz
+
+ARG mongodb_agent_version_s390x
+ADD "${mongodb_agent_url}/${mongodb_agent_version_s390x}" /data/s390x/mongodb_agent.tgz
+
+ARG mongodb_agent_version_ppc64le
+ADD "${mongodb_agent_url}/${mongodb_agent_version_ppc64le}" /data/ppc64le/mongodb_agent.tgz
+
+FROM registry.access.redhat.com/ubi9/ubi-minimal
+
+ARG TARGETARCH
+COPY --from=tools_downloader "/data/${TARGETARCH}/mongodb_tools.tgz" /tools/mongodb_tools.tgz
+COPY --from=agent_downloader "/data/${TARGETARCH}/mongodb_agent.tgz" /agent/mongodb_agent.tgz
 
 # Replace libcurl-minimal and curl-minimal with the full versions
 # https://bugzilla.redhat.com/show_bug.cgi?id=1994521
@@ -50,26 +64,32 @@ RUN mkdir -p /agent \
       && touch /var/log/mongodb-mms-automation/readiness.log \
       && chmod ugo+rw /var/log/mongodb-mms-automation/readiness.log
 
-
-COPY --from=base /data/mongodb-agent.tar.gz /agent
-COPY --from=base /data/mongodb-tools.tgz /agent
-COPY --from=base /data/LICENSE /licenses/LICENSE
-
 # Copy scripts to a safe location that won't be overwritten by volume mount
-COPY --from=base /opt/scripts/agent-launcher-shim.sh /usr/local/bin/agent-launcher-shim.sh
-COPY --from=base /opt/scripts/setup-agent-files.sh /usr/local/bin/setup-agent-files.sh
-COPY --from=base /opt/scripts/dummy-probe.sh /usr/local/bin/dummy-probe.sh
-COPY --from=base /opt/scripts/dummy-readinessprobe.sh /usr/local/bin/dummy-readinessprobe
+COPY ./docker/mongodb-agent/agent-launcher-shim.sh /usr/local/bin/agent-launcher-shim.sh
+COPY ./docker/mongodb-agent/setup-agent-files.sh /usr/local/bin/setup-agent-files.sh
+COPY ./docker/mongodb-agent/dummy-probe.sh /usr/local/bin/dummy-probe.sh
+COPY ./docker/mongodb-agent/dummy-readinessprobe.sh /usr/local/bin/dummy-readinessprobe
+COPY ./docker/mongodb-kubernetes-init-database/content/LICENSE /licenses/LICENSE
 
-RUN tar xfz /agent/mongodb-agent.tar.gz \
+RUN tar xfz /agent/mongodb_agent.tgz \
     && mv mongodb-mms-automation-agent-*/mongodb-mms-automation-agent /agent/mongodb-agent \
     && chmod +x /agent/mongodb-agent \
     && mkdir -p /var/lib/automation/config \
     && chmod -R +r /var/lib/automation/config \
-    && rm /agent/mongodb-agent.tar.gz \
+    && rm /agent/mongodb_agent.tgz \
     && rm -r mongodb-mms-automation-agent-*
 
-RUN tar xfz /agent/mongodb-tools.tgz --directory /var/lib/mongodb-mms-automation/ && rm /agent/mongodb-tools.tgz
+RUN tar xfz /tools/mongodb_tools.tgz --directory /var/lib/mongodb-mms-automation/ && rm /tools/mongodb_tools.tgz
+
+ARG version
+
+LABEL name="MongoDB Agent" \
+      version="${version}" \
+      summary="MongoDB Agent" \
+      description="MongoDB Agent" \
+      vendor="MongoDB" \
+      release="1" \
+      maintainer="support@mongodb.com"
 
 USER 2000
 CMD ["/agent/mongodb-agent", "-cluster=/var/lib/automation/config/automation-config.json"]
diff --git a/docker/mongodb-agent-non-matrix/README.md b/docker/mongodb-agent-non-matrix/README.md
index 79dc0d2d5..c50d889c4 100644
--- a/docker/mongodb-agent-non-matrix/README.md
+++ b/docker/mongodb-agent-non-matrix/README.md
@@ -6,12 +6,22 @@ TODO: What to do with label quay.expires-after=48h?
 ```bash
 AGENT_VERSION="108.0.7.8810-1"
 TOOLS_VERSION="100.12.0"
-AGENT_DISTRO="rhel9_x86_64"
-TOOLS_DISTRO="rhel93-x86_64"
-docker buildx build --load --progress plain . -f docker/mongodb-agent/Dockerfile -t "mongodb-agent:${AGENT_VERSION}" \
- --build-arg version="${VERSION}" \
- --build-arg agent_version="${AGENT_VERSION}" \
- --build-arg tools_version="${TOOLS_VERSION}" \
- --build-arg agent_distro="${AGENT_DISTRO}" \
- --build-arg tools_distro="${TOOLS_DISTRO}"
+MONGODB_TOOLS_URL="https://downloads.mongodb.org/tools/db"
+MONGODB_AGENT_URL="https://mciuploads.s3.amazonaws.com/mms-automation/mongodb-mms-build-agent/builds/automation-agent/prod"
+BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa/"
+
+docker buildx build --progress plain --platform linux/amd64,linux/arm64,linux/s390x,linux/ppc64le . -f docker/mongodb-agent-non-matrix/Dockerfile -t "${BASE_REPO_URL}mongodb-agent:${AGENT_VERSION}" \
+    --build-arg version="${AGENT_VERSION}" \
+    --build-arg mongodb_tools_url="${MONGODB_TOOLS_URL}" \
+    --build-arg mongodb_agent_url="${MONGODB_AGENT_URL}" \
+    --build-arg mongodb_agent_version_s390x="mongodb-mms-automation-agent-${AGENT_VERSION}.rhel7_s390x.tar.gz" \
+    --build-arg mongodb_agent_version_ppc64le="mongodb-mms-automation-agent-${AGENT_VERSION}.rhel8_ppc64le.tar.gz" \
+    --build-arg mongodb_agent_version_amd64="mongodb-mms-automation-agent-${AGENT_VERSION}.linux_x86_64.tar.gz" \
+    --build-arg mongodb_agent_version_arm64="mongodb-mms-automation-agent-${AGENT_VERSION}.amzn2_aarch64.tar.gz" \
+    --build-arg mongodb_tools_version_arm64="mongodb-database-tools-rhel93-aarch64-${TOOLS_VERSION}.tgz" \
+    --build-arg mongodb_tools_version_amd64="mongodb-database-tools-rhel93-x86_64-${TOOLS_VERSION}.tgz" \
+    --build-arg mongodb_tools_version_s390x="mongodb-database-tools-rhel9-s390x-${TOOLS_VERSION}.tgz" \
+    --build-arg mongodb_tools_version_ppc64le="mongodb-database-tools-rhel9-ppc64le-${TOOLS_VERSION}.tgz"
+
+docker push "${BASE_REPO_URL}mongodb-agent:${AGENT_VERSION}"
 ```
diff --git a/docker/mongodb-agent/Dockerfile b/docker/mongodb-agent/Dockerfile
index 5ec4e127b..b58933002 100644
--- a/docker/mongodb-agent/Dockerfile
+++ b/docker/mongodb-agent/Dockerfile
@@ -3,57 +3,66 @@
 ARG init_database_image
 FROM ${init_database_image} AS init_database
 
-FROM public.ecr.aws/docker/library/golang:1.24 AS dependency_downloader
+FROM scratch AS tools_downloader
 
-WORKDIR /go/src/github.com/mongodb/mongodb-kubernetes/
+ARG mongodb_tools_url
 
-COPY go.mod go.sum ./
+ARG mongodb_tools_version_amd64
+ADD "${mongodb_tools_url}/${mongodb_tools_version_amd64}" /data/amd64/mongodb_tools.tgz
 
-RUN go mod download
+ARG mongodb_tools_version_arm64
+ADD "${mongodb_tools_url}/${mongodb_tools_version_arm64}" /data/arm64/mongodb_tools.tgz
 
-FROM public.ecr.aws/docker/library/golang:1.24 AS readiness_builder
+ARG mongodb_tools_version_s390x
+ADD "${mongodb_tools_url}/${mongodb_tools_version_s390x}" /data/s390x/mongodb_tools.tgz
 
-WORKDIR /go/src/github.com/mongodb/mongodb-kubernetes/
+ARG mongodb_tools_version_ppc64le
+ADD "${mongodb_tools_url}/${mongodb_tools_version_ppc64le}" /data/ppc64le/mongodb_tools.tgz
+
+FROM scratch AS agent_downloader
 
-COPY --from=dependency_downloader /go/pkg /go/pkg
-COPY . /go/src/github.com/mongodb/mongodb-kubernetes
+ARG mongodb_agent_url
 
-RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false go build -o /readinessprobe ./mongodb-community-operator/cmd/readiness/main.go
-RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false go build -o /version-upgrade-hook ./mongodb-community-operator/cmd/versionhook/main.go
+ARG mongodb_agent_version_amd64
+ADD "${mongodb_agent_url}/${mongodb_agent_version_amd64}" /data/amd64/mongodb_agent.tgz
 
-FROM scratch AS base
-ARG mongodb_tools_url_ubi
-ARG mongodb_agent_url_ubi
+ARG mongodb_agent_version_arm64
+ADD "${mongodb_agent_url}/${mongodb_agent_version_arm64}" /data/arm64/mongodb_agent.tgz
 
-COPY --from=readiness_builder /readinessprobe /data/
-COPY --from=readiness_builder /version-upgrade-hook /data/
+ARG mongodb_agent_version_s390x
+ADD "${mongodb_agent_url}/${mongodb_agent_version_s390x}" /data/s390x/mongodb_agent.tgz
 
-ADD ${mongodb_tools_url_ubi} /data/mongodb_tools_ubi.tgz
-ADD ${mongodb_agent_url_ubi} /data/mongodb_agent_ubi.tgz
+ARG mongodb_agent_version_ppc64le
+ADD "${mongodb_agent_url}/${mongodb_agent_version_ppc64le}" /data/ppc64le/mongodb_agent.tgz
 
-COPY --from=init_database /probes/probe.sh /data/probe.sh
-COPY --from=init_database /scripts/agent-launcher-lib.sh /data/
-COPY --from=init_database /scripts/agent-launcher.sh /data/
-COPY --from=init_database /licenses/LICENSE /data/
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.24 AS readiness_builder
+
+WORKDIR /go/src/github.com/mongodb/mongodb-kubernetes/
+
+COPY go.mod go.sum ./
+
+RUN go mod download
+
+COPY mongodb-community-operator /go/src/github.com/mongodb/mongodb-kubernetes/mongodb-community-operator
+
+ARG TARGETOS
+ARG TARGETARCH
+RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /readinessprobe ./mongodb-community-operator/cmd/readiness/main.go
+RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /version-upgrade-hook ./mongodb-community-operator/cmd/versionhook/main.go
 
 FROM registry.access.redhat.com/ubi9/ubi-minimal
 
-ARG version
+ARG TARGETARCH
+COPY --from=tools_downloader "/data/${TARGETARCH}/mongodb_tools.tgz" /tools/mongodb_tools.tgz
+COPY --from=agent_downloader "/data/${TARGETARCH}/mongodb_agent.tgz" /agent/mongodb_agent.tgz
 
-LABEL name="MongoDB Agent" \
-      version="${version}" \
-      summary="MongoDB Agent" \
-      description="MongoDB Agent" \
-      vendor="MongoDB" \
-      release="1" \
-      maintainer="support@mongodb.com"
+COPY --from=readiness_builder /readinessprobe /opt/scripts/readinessprobe
+COPY --from=readiness_builder /version-upgrade-hook /opt/scripts/version-upgrade-hook
 
-COPY --from=base /data/probe.sh /opt/scripts/probe.sh
-COPY --from=base /data/readinessprobe /opt/scripts/readinessprobe
-COPY --from=base /data/version-upgrade-hook /opt/scripts/version-upgrade-hook
-COPY --from=base /data/agent-launcher-lib.sh /opt/scripts/agent-launcher-lib.sh
-COPY --from=base /data/agent-launcher.sh /opt/scripts/agent-launcher.sh
-COPY --from=base /data/LICENSE /licenses/LICENSE
+COPY --from=init_database /probes/probe.sh /opt/scripts/probe.sh
+COPY --from=init_database /scripts/agent-launcher-lib.sh /opt/scripts/agent-launcher-lib.sh
+COPY --from=init_database /scripts/agent-launcher.sh /opt/scripts/agent-launcher.sh
+COPY --from=init_database /licenses/LICENSE /licenses/LICENSE
 
 # Replace libcurl-minimal and curl-minimal with the full versions
 # https://bugzilla.redhat.com/show_bug.cgi?id=1994521
@@ -75,10 +84,6 @@ RUN microdnf install -y --disableplugin=subscription-manager \
     && microdnf upgrade -y  \
     && rm -rf /var/lib/apt/lists/*
 
-
-COPY --from=base /data/mongodb_tools_ubi.tgz /tools/mongodb_tools.tgz
-COPY --from=base /data/mongodb_agent_ubi.tgz /agent/mongodb_agent.tgz
-
 RUN tar xfz /tools/mongodb_tools.tgz
 RUN mv mongodb-database-tools-*/bin/* /tools
 RUN chmod +x /tools/*
@@ -94,6 +99,16 @@ RUN rm -rf mongodb-mms-automation-agent-*
 RUN mkdir -p /var/lib/automation/config
 RUN chmod -R +r /var/lib/automation/config
 
+ARG version
+
+LABEL name="MongoDB Agent" \
+      version="${version}" \
+      summary="MongoDB Agent" \
+      description="MongoDB Agent" \
+      vendor="MongoDB" \
+      release="1" \
+      maintainer="support@mongodb.com"
+
 USER 2000
 
 HEALTHCHECK --timeout=30s CMD ls /opt/scripts/readinessprobe || exit 1
diff --git a/docker/mongodb-agent/README.md b/docker/mongodb-agent/README.md
index a447d60f0..91fc2ca1f 100644
--- a/docker/mongodb-agent/README.md
+++ b/docker/mongodb-agent/README.md
@@ -8,13 +8,28 @@ binaries from there. Then we continue with the other steps to fully build the im
 For building the MongoDB Agent image locally use the example command:
 
 ```bash
-VERSION="108.0.7.8810-1"
-INIT_DATABASE_IMAGE="268558157000.dkr.ecr.us-east-1.amazonaws.com/dev/mongodb-kubernetes-init-database:1.1.0"
-MONGODB_TOOLS_URL_UBI="https://downloads.mongodb.org/tools/db/mongodb-database-tools-rhel93-x86_64-100.12.0.tgz"
-MONGODB_AGENT_URL_UBI="https://mciuploads.s3.amazonaws.com/mms-automation/mongodb-mms-build-agent/builds/automation-agent/prod/mongodb-mms-automation-agent-108.0.7.8810-1.rhel9_x86_64.tar.gz"
-docker buildx build --load --progress plain . -f docker/mongodb-agent/Dockerfile -t "mongodb-agent:${VERSION}_1.1.0" \
- --build-arg version="${VERSION}" \
- --build-arg init_database_image="${INIT_DATABASE_IMAGE}" \
- --build-arg mongodb_tools_url_ubi="${MONGODB_TOOLS_URL_UBI}" \
- --build-arg mongodb_agent_url_ubi="${MONGODB_AGENT_URL_UBI}"
+VERSION="evergreen"
+AGENT_VERSION="108.0.7.8810-1"
+TOOLS_VERSION="100.12.0"
+MONGODB_TOOLS_URL="https://downloads.mongodb.org/tools/db"
+MONGODB_AGENT_URL="https://mciuploads.s3.amazonaws.com/mms-automation/mongodb-mms-build-agent/builds/automation-agent/prod"
+BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa/"
+INIT_DATABASE_IMAGE="${BASE_REPO_URL}mongodb-kubernetes-init-database:${VERSION}"
+
+docker buildx build --progress plain --platform linux/amd64,linux/arm64,linux/s390x,linux/ppc64le . -f docker/mongodb-agent/Dockerfile -t "${BASE_REPO_URL}mongodb-agent:${AGENT_VERSION}_${VERSION}" \
+    --build-arg version="${VERSION}" \
+    --build-arg init_database_image="${INIT_DATABASE_IMAGE}" \
+    --build-arg mongodb_tools_url="${MONGODB_TOOLS_URL}" \
+    --build-arg mongodb_agent_url="${MONGODB_AGENT_URL}" \
+    --build-arg mongodb_agent_version_s390x="mongodb-mms-automation-agent-${AGENT_VERSION}.rhel7_s390x.tar.gz" \
+    --build-arg mongodb_agent_version_ppc64le="mongodb-mms-automation-agent-${AGENT_VERSION}.rhel8_ppc64le.tar.gz" \
+    --build-arg mongodb_agent_version_amd64="mongodb-mms-automation-agent-${AGENT_VERSION}.linux_x86_64.tar.gz" \
+    --build-arg mongodb_agent_version_arm64="mongodb-mms-automation-agent-${AGENT_VERSION}.amzn2_aarch64.tar.gz" \
+    --build-arg mongodb_tools_version_arm64="mongodb-database-tools-rhel93-aarch64-${TOOLS_VERSION}.tgz" \
+    --build-arg mongodb_tools_version_amd64="mongodb-database-tools-rhel93-x86_64-${TOOLS_VERSION}.tgz" \
+    --build-arg mongodb_tools_version_s390x="mongodb-database-tools-rhel9-s390x-${TOOLS_VERSION}.tgz" \
+    --build-arg mongodb_tools_version_ppc64le="mongodb-database-tools-rhel9-ppc64le-${TOOLS_VERSION}.tgz"
+
+docker push "${BASE_REPO_URL}mongodb-agent:${AGENT_VERSION}_${VERSION}"
+
 ```
diff --git a/docker/mongodb-kubernetes-database/Dockerfile b/docker/mongodb-kubernetes-database/Dockerfile
index 97fbda8d0..43f705fdd 100644
--- a/docker/mongodb-kubernetes-database/Dockerfile
+++ b/docker/mongodb-kubernetes-database/Dockerfile
@@ -41,7 +41,8 @@ RUN microdnf install -y --disableplugin=subscription-manager \
         jq \
         tar \
         xz-libs \
-        findutils
+        findutils \
+        cpio
 
 RUN ln -s /usr/lib64/libsasl2.so.3 /usr/lib64/libsasl2.so.2
 
diff --git a/docker/mongodb-kubernetes-database/README.md b/docker/mongodb-kubernetes-database/README.md
index e7b937e0e..7dd70a6fa 100644
--- a/docker/mongodb-kubernetes-database/README.md
+++ b/docker/mongodb-kubernetes-database/README.md
@@ -39,7 +39,10 @@ this images with.
 For building the MongoDB Database image locally use the example command:
 
 ```bash
-VERSION="1.0.1"
-docker buildx build --load --progress plain . -f docker/mongodb-kubernetes-database/Dockerfile -t "mongodb-kubernetes-database:${VERSION}" \
+VERSION="1.3.0"
+BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa/"
+docker buildx build --load --progress plain --platform linux/amd64,linux/arm64,linux/s390x,linux/ppc64le . -f docker/mongodb-kubernetes-database/Dockerfile -t "${BASE_REPO_URL}mongodb-kubernetes-database:${VERSION}" \
  --build-arg VERSION="${VERSION}"
+
+docker push "${BASE_REPO_URL}mongodb-kubernetes-database:${VERSION}"
 ```
diff --git a/docker/mongodb-kubernetes-init-appdb/Dockerfile b/docker/mongodb-kubernetes-init-appdb/Dockerfile
index ed0cea9dd..704361276 100644
--- a/docker/mongodb-kubernetes-init-appdb/Dockerfile
+++ b/docker/mongodb-kubernetes-init-appdb/Dockerfile
@@ -1,19 +1,18 @@
-FROM public.ecr.aws/docker/library/golang:1.24 AS readiness_builder
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.24 AS readiness_builder
+
+ARG TARGETOS
+ARG TARGETARCH
 
 COPY . /go/src/github.com/mongodb/mongodb-kubernetes
 WORKDIR /go/src/github.com/mongodb/mongodb-kubernetes
-RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false go build -o /readinessprobe ./mongodb-community-operator/cmd/readiness/main.go
-RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false go build -o /version-upgrade-hook ./mongodb-community-operator/cmd/versionhook/main.go
+RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /readinessprobe ./mongodb-community-operator/cmd/readiness/main.go
+RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /version-upgrade-hook ./mongodb-community-operator/cmd/versionhook/main.go
 
 FROM scratch AS base
 
-ARG mongodb_tools_url_ubi
-
 COPY --from=readiness_builder /readinessprobe /data/
 COPY --from=readiness_builder /version-upgrade-hook /data/version-upgrade-hook
 
-ADD ${mongodb_tools_url_ubi} /data/mongodb_tools_ubi.tgz
-
 COPY ./docker/mongodb-kubernetes-init-database/content/probe.sh /data/probe.sh
 
 COPY ./docker/mongodb-kubernetes-init-database/content/agent-launcher-lib.sh /data/scripts/
@@ -23,6 +22,7 @@ COPY ./docker/mongodb-kubernetes-init-database/content/LICENSE /data/licenses/
 
 FROM registry.access.redhat.com/ubi8/ubi-minimal
 
+ARG TARGETPLATFORM
 ARG version
 LABEL name="MongoDB Kubernetes Init AppDB" \
       version="mongodb-kubernetes-init-appdb-${version}" \
@@ -42,7 +42,20 @@ RUN microdnf -y update --nodocs \
     && microdnf -y install --nodocs tar gzip \
     && microdnf clean all
 
-COPY --from=base /data/mongodb_tools_ubi.tgz /tools/mongodb_tools.tgz
+ARG mongodb_tools_url
+ARG mongodb_tools_version_s390x
+ARG mongodb_tools_version_ppc64le
+ARG mongodb_tools_version_amd64
+ARG mongodb_tools_version_arm64
+
+RUN case ${TARGETPLATFORM} in \
+     "linux/amd64")   export MONGODB_TOOLS_VERSION=${mongodb_tools_version_amd64}    ;; \
+     "linux/arm64")   export MONGODB_TOOLS_VERSION=${mongodb_tools_version_arm64}    ;; \
+     "linux/s390x")   export MONGODB_TOOLS_VERSION=${mongodb_tools_version_s390x}    ;; \
+     "linux/ppc64le") export MONGODB_TOOLS_VERSION=${mongodb_tools_version_ppc64le}  ;; \
+  esac \
+    && mkdir -p /tools \
+    && curl -o /tools/mongodb_tools.tgz "${mongodb_tools_url}/${MONGODB_TOOLS_VERSION}"
 
 RUN tar xfz /tools/mongodb_tools.tgz --directory /tools \
     && rm /tools/mongodb_tools.tgz
diff --git a/docker/mongodb-kubernetes-init-appdb/README.md b/docker/mongodb-kubernetes-init-appdb/README.md
index d49ca4b3a..f3d51eb1c 100644
--- a/docker/mongodb-kubernetes-init-appdb/README.md
+++ b/docker/mongodb-kubernetes-init-appdb/README.md
@@ -3,9 +3,14 @@
 For building the MongoDB Init AppDB image locally use the example command:
 
 ```bash
-VERSION="1.0.1"
-MONGODB_TOOLS_URL_UBI="https://downloads.mongodb.org/tools/db/mongodb-database-tools-rhel93-x86_64-100.12.0.tgz"
-docker buildx build --load --progress plain . -f docker/mongodb-kubernetes-init-appdb/Dockerfile -t "mongodb-kubernetes-init-appdb:${VERSION}" \
+VERSION="1.3.0"
+MONGODB_TOOLS_URL="https://downloads.mongodb.org/tools/db"
+BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa/"
+docker buildx build --load --progress plain --platform linux/amd64,linux/arm64,linux/s390x,linux/ppc64le . -f docker/mongodb-kubernetes-init-appdb/Dockerfile -t "${BASE_REPO_URL}mongodb-kubernetes-init-appdb:${VERSION}" \
  --build-arg version="${VERSION}" \
- --build-arg mongodb_tools_url_ubi="${MONGODB_TOOLS_URL_UBI}"
+ --build-arg mongodb_tools_url="${MONGODB_TOOLS_URL_UBI}" \
+ --build-arg mongodb_tools_version_arm64="mongodb-database-tools-rhel93-aarch64-100.12.0.tgz" \
+ --build-arg mongodb_tools_version_amd64="mongodb-database-tools-rhel93-x86_64-100.12.0.tgz" \
+ --build-arg mongodb_tools_version_s390x="mongodb-database-tools-rhel9-s390x-100.12.0.tgz" \
+ --build-arg mongodb_tools_version_ppc64le="mongodb-database-tools-rhel9-ppc64le-100.12.0.tgz"
 ```
diff --git a/docker/mongodb-kubernetes-init-database/Dockerfile b/docker/mongodb-kubernetes-init-database/Dockerfile
index 6c861fb6a..3f38f7870 100644
--- a/docker/mongodb-kubernetes-init-database/Dockerfile
+++ b/docker/mongodb-kubernetes-init-database/Dockerfile
@@ -1,18 +1,38 @@
-FROM public.ecr.aws/docker/library/golang:1.24 AS readiness_builder
+FROM scratch AS tools_downloader
 
-COPY . /go/src/github.com/mongodb/mongodb-kubernetes
-WORKDIR /go/src/github.com/mongodb/mongodb-kubernetes
-RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false go build -o /readinessprobe ./mongodb-community-operator/cmd/readiness/main.go
-RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false go build -o /version-upgrade-hook ./mongodb-community-operator/cmd/versionhook/main.go
+ARG mongodb_tools_url
 
-FROM scratch AS base
+ARG mongodb_tools_version_amd64
+ADD "${mongodb_tools_url}/${mongodb_tools_version_amd64}" /data/amd64/mongodb_tools.tgz
 
-ARG mongodb_tools_url_ubi
+ARG mongodb_tools_version_arm64
+ADD "${mongodb_tools_url}/${mongodb_tools_version_arm64}" /data/arm64/mongodb_tools.tgz
 
-COPY --from=readiness_builder /readinessprobe /data/
-COPY --from=readiness_builder /version-upgrade-hook /data/version-upgrade-hook
+ARG mongodb_tools_version_s390x
+ADD "${mongodb_tools_url}/${mongodb_tools_version_s390x}" /data/s390x/mongodb_tools.tgz
+
+ARG mongodb_tools_version_ppc64le
+ADD "${mongodb_tools_url}/${mongodb_tools_version_ppc64le}" /data/ppc64le/mongodb_tools.tgz
+
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.24 AS readiness_builder
+
+WORKDIR /go/src/github.com/mongodb/mongodb-kubernetes/
+
+COPY go.mod go.sum ./
+
+RUN go mod download
+
+COPY mongodb-community-operator /go/src/github.com/mongodb/mongodb-kubernetes/mongodb-community-operator
+
+ARG TARGETOS
+ARG TARGETARCH
+RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /readinessprobe ./mongodb-community-operator/cmd/readiness/main.go
+RUN CGO_ENABLED=0 GOFLAGS=-buildvcs=false GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /version-upgrade-hook ./mongodb-community-operator/cmd/versionhook/main.go
 
-ADD ${mongodb_tools_url_ubi} /data/mongodb_tools_ubi.tgz
+FROM scratch AS base
+
+COPY --from=readiness_builder /readinessprobe /data/readinessprobe
+COPY --from=readiness_builder /version-upgrade-hook /data/version-upgrade-hook
 
 COPY ./docker/mongodb-kubernetes-init-database/content/probe.sh /data/probe.sh
 
@@ -21,8 +41,24 @@ COPY ./docker/mongodb-kubernetes-init-database/content/agent-launcher.sh /data/s
 
 COPY ./docker/mongodb-kubernetes-init-database/content/LICENSE /data/licenses/
 
+#TODO ubi9?
 FROM registry.access.redhat.com/ubi8/ubi-minimal
 
+ARG TARGETARCH
+COPY --from=tools_downloader /data/${TARGETARCH}/mongodb_tools.tgz /tools/mongodb_tools.tgz
+
+RUN microdnf -y update --nodocs \
+  && microdnf -y install --nodocs tar gzip \
+  && microdnf clean all
+
+RUN tar xfz /tools/mongodb_tools.tgz --directory /tools \
+    && rm /tools/mongodb_tools.tgz
+
+COPY --from=base /data/readinessprobe /probes/readinessprobe
+COPY --from=base /data/probe.sh /probes/probe.sh
+COPY --from=base /data/scripts/ /scripts/
+COPY --from=base /data/licenses /licenses/
+
 ARG version
 LABEL name="MongoDB Kubernetes Init Database" \
       version="mongodb-kubernetes-init-database-${version}" \
@@ -32,19 +68,6 @@ LABEL name="MongoDB Kubernetes Init Database" \
       vendor="MongoDB" \
       maintainer="support@mongodb.com"
 
-COPY --from=base /data/readinessprobe /probes/readinessprobe
-COPY --from=base /data/probe.sh /probes/probe.sh
-COPY --from=base /data/scripts/ /scripts/
-COPY --from=base /data/licenses /licenses/
-
-RUN microdnf -y update --nodocs \
-    && microdnf -y install --nodocs tar gzip \
-    && microdnf clean all
-
-COPY --from=base /data/mongodb_tools_ubi.tgz  /tools/mongodb_tools.tgz
-
-RUN tar xfz /tools/mongodb_tools.tgz --directory /tools \
-    && rm /tools/mongodb_tools.tgz
-
 USER 2000
+
 ENTRYPOINT [ "/bin/cp", "-f", "-r", "/scripts/agent-launcher.sh", "/scripts/agent-launcher-lib.sh", "/probes/readinessprobe", "/probes/probe.sh", "/tools", "/opt/scripts/" ]
diff --git a/docker/mongodb-kubernetes-init-database/README.md b/docker/mongodb-kubernetes-init-database/README.md
index 0e6657531..04571f284 100644
--- a/docker/mongodb-kubernetes-init-database/README.md
+++ b/docker/mongodb-kubernetes-init-database/README.md
@@ -3,9 +3,20 @@
 For building the MongoDB Init AppDB image locally use the example command:
 
 ```bash
-VERSION="1.0.1"
-MONGODB_TOOLS_URL_UBI="https://downloads.mongodb.org/tools/db/mongodb-database-tools-rhel93-x86_64-100.12.0.tgz"
-docker buildx build --load --progress plain . -f docker/mongodb-kubernetes-init-database/Dockerfile -t "mongodb-kubernetes-init-database:${VERSION}" \
+VERSION="evergreen"
+TOOLS_VERSION="100.12.0"
+MONGODB_TOOLS_URL_UBI="https://downloads.mongodb.org/tools/db"
+BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa/"
+docker buildx build --progress plain --platform linux/amd64,linux/arm64,linux/s390x,linux/ppc64le . -f docker/mongodb-kubernetes-init-database/Dockerfile -t "${BASE_REPO_URL}mongodb-kubernetes-init-database:${VERSION}" \
  --build-arg version="${VERSION}" \
- --build-arg mongodb_tools_url_ubi="${MONGODB_TOOLS_URL_UBI}"
+ --build-arg mongodb_tools_url="${MONGODB_TOOLS_URL_UBI}" \
+ --build-arg mongodb_tools_version_arm64="mongodb-database-tools-rhel93-aarch64-${TOOLS_VERSION}.tgz" \
+ --build-arg mongodb_tools_version_amd64="mongodb-database-tools-rhel93-x86_64-${TOOLS_VERSION}.tgz" \
+ --build-arg mongodb_tools_version_s390x="mongodb-database-tools-rhel9-s390x-${TOOLS_VERSION}.tgz" \
+ --build-arg mongodb_tools_version_ppc64le="mongodb-database-tools-rhel9-ppc64le-${TOOLS_VERSION}.tgz"
+
+docker push "${BASE_REPO_URL}mongodb-kubernetes-init-database:${VERSION}"
 ```
+
+first no cache 2:20.28 total
+second no cache 2:31.74 total
diff --git a/docker/mongodb-kubernetes-init-database/content/agent-launcher-lib.sh b/docker/mongodb-kubernetes-init-database/content/agent-launcher-lib.sh
index eaed81cf0..01060832b 100755
--- a/docker/mongodb-kubernetes-init-database/content/agent-launcher-lib.sh
+++ b/docker/mongodb-kubernetes-init-database/content/agent-launcher-lib.sh
@@ -91,10 +91,21 @@ download_agent() {
       AGENT_VERSION="${MDB_AGENT_VERSION}"
     fi
 
+    if [ "$(arch)" = "x86_64" ]; then
+        AGENT_FILE="mongodb-mms-automation-agent-${AGENT_VERSION}.linux_x86_64.tar.gz"
+    elif [ "$(arch)" = "arm64" ]; then
+        AGENT_FILE="mongodb-mms-automation-agent-${AGENT_VERSION}.amzn2_aarch64.tar.gz"
+    elif [ "$(arch)" = "ppc64le" ]; then
+        AGENT_FILE="mongodb-mms-automation-agent-${AGENT_VERSION}.rhel8_ppc64le.tar.gz"
+    elif [ "$(arch)" = "s390x" ]; then
+        AGENT_FILE="mongodb-mms-automation-agent-${AGENT_VERSION}.rhel7_s390x.tar.gz"
+    fi
+
     script_log "Downloading Agent version: ${AGENT_VERSION}"
     script_log "Downloading a Mongodb Agent from ${base_url:?}"
     curl_opts=(
-        "${base_url}/download/agent/automation/mongodb-mms-automation-agent-${AGENT_VERSION}.linux_x86_64.tar.gz"
+        "${base_url}/download/agent/automation/${AGENT_FILE}"
+
         "--location" "--silent" "--retry" "3" "--fail" "-v"
         "--output" "automation-agent.tar.gz"
     );
@@ -117,13 +128,15 @@ download_agent() {
     rm "${MMS_LOG_DIR}/curl.log" 2>/dev/null || true
 
     script_log "The Mongodb Agent binary downloaded, unpacking"
+
+    mkdir -p "${MMS_HOME}/files"
     tar -xzf automation-agent.tar.gz
     AGENT_VERSION=$(find . -name "mongodb-mms-automation-agent-*" | awk -F"-" '{ print $5 }')
-    mkdir -p "${MMS_HOME}/files"
-    echo "${AGENT_VERSION}" >"${MMS_HOME}/files/agent-version"
     mv mongodb-mms-automation-agent-*/mongodb-mms-automation-agent "${MMS_HOME}/files/"
+    rm -rf automation-agent.tar.gz mongodb-mms-automation-agent-*.*
+
+    echo "${AGENT_VERSION}" >"${MMS_HOME}/files/agent-version"
     chmod +x "${MMS_HOME}/files/mongodb-mms-automation-agent"
-    rm -rf automation-agent.tar.gz mongodb-mms-automation-agent-*.linux_x86_64
     script_log "The Automation Agent was deployed at ${MMS_HOME}/files/mongodb-mms-automation-agent"
 
     popd >/dev/null || true
diff --git a/docker/mongodb-kubernetes-operator/Dockerfile b/docker/mongodb-kubernetes-operator/Dockerfile
index dcd3af35c..8253c5e4f 100644
--- a/docker/mongodb-kubernetes-operator/Dockerfile
+++ b/docker/mongodb-kubernetes-operator/Dockerfile
@@ -1,8 +1,8 @@
-FROM public.ecr.aws/docker/library/golang:1.24 AS builder
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.24 AS builder
 
-ARG version
-ARG log_automation_config_diff
-ARG use_race
+ARG BUILDARCH
+ADD "https://github.com/stedolan/jq/releases/download/jq-1.8.1/jq-linux-${BUILDARCH}" /usr/local/bin/jq
+RUN chmod +x /usr/local/bin/jq
 
 COPY go.sum go.mod /go/src/github.com/mongodb/mongodb-kubernetes/
 
@@ -11,28 +11,28 @@ RUN go mod download
 
 COPY . /go/src/github.com/mongodb/mongodb-kubernetes
 
-RUN go version
-RUN git version
+ARG version
+ARG log_automation_config_diff
+ARG use_race
+ARG TARGETOS
+ARG TARGETARCH
+
 RUN mkdir /build && \
     if [ $use_race = "true" ]; then \
         echo "Building with race detector" && \
-        CGO_ENABLED=1 go build -o /build/mongodb-kubernetes-operator \
+        CGO_ENABLED=1 GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /build/mongodb-kubernetes-operator \
         -buildvcs=false \
         -race \
         -ldflags=" -X github.com/mongodb/mongodb-kubernetes/pkg/util.OperatorVersion=${version} \
         -X github.com/mongodb/mongodb-kubernetes/pkg/util.LogAutomationConfigDiff=${log_automation_config_diff}"; \
     else \
         echo "Building without race detector" && \
-        CGO_ENABLED=0 go build -o /build/mongodb-kubernetes-operator \
+        CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -o /build/mongodb-kubernetes-operator \
         -buildvcs=false \
         -ldflags="-s -w -X github.com/mongodb/mongodb-kubernetes/pkg/util.OperatorVersion=${version} \
         -X github.com/mongodb/mongodb-kubernetes/pkg/util.LogAutomationConfigDiff=${log_automation_config_diff}"; \
     fi
 
-
-ADD https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64 /usr/local/bin/jq
-RUN chmod +x /usr/local/bin/jq
-
 RUN mkdir -p /data
 RUN cat release.json | jq -r '.supportedImages."mongodb-agent" | { "supportedImages": { "mongodb-agent": . } }' > /data/om_version_mapping.json
 RUN chmod +r /data/om_version_mapping.json
@@ -46,16 +46,6 @@ ADD docker/mongodb-kubernetes-operator/licenses /data/licenses/
 
 FROM registry.access.redhat.com/ubi9/ubi-minimal
 
-ARG version
-
-LABEL name="MongoDB Kubernetes Operator" \
-      maintainer="support@mongodb.com" \
-      vendor="MongoDB" \
-      version="${version}" \
-      release="1" \
-      summary="MongoDB Kubernetes Operator Image" \
-      description="MongoDB Kubernetes Operator Image"
-
 # Building an UBI-based image: https://red.ht/3n6b9y0
 RUN microdnf update \
     --disableplugin=subscription-manager \
@@ -67,6 +57,16 @@ COPY --from=base /data/mongodb-kubernetes-operator /usr/local/bin/mongodb-kubern
 COPY --from=base /data/om_version_mapping.json /usr/local/om_version_mapping.json
 COPY --from=base /data/licenses /licenses/
 
+ARG version
+
+LABEL name="MongoDB Kubernetes Operator" \
+      maintainer="support@mongodb.com" \
+      vendor="MongoDB" \
+      version="${version}" \
+      release="1" \
+      summary="MongoDB Kubernetes Operator Image" \
+      description="MongoDB Kubernetes Operator Image"
+
 USER 2000
 
 ENTRYPOINT exec /usr/local/bin/mongodb-kubernetes-operator
diff --git a/docker/mongodb-kubernetes-operator/README.md b/docker/mongodb-kubernetes-operator/README.md
index 8335c1d79..546ed893c 100644
--- a/docker/mongodb-kubernetes-operator/README.md
+++ b/docker/mongodb-kubernetes-operator/README.md
@@ -13,13 +13,16 @@ CGO_ENABLED=0 GOOS=linux GOFLAGS="-mod=vendor" go build -i -o mongodb-kubernetes
 For building the MongoDB Init Ops Manager image locally use the example command:
 
 ```bash
-VERSION="1.1.0"
+VERSION="evergreen"
 LOG_AUTOMATION_CONFIG_DIFF="false"
 USE_RACE="false"
-docker buildx build --load --progress plain . -f docker/mongodb-kubernetes-operator/Dockerfile -t "mongodb-kubernetes-operator:${VERSION}" \
+BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa/"
+docker buildx build --load --progress plain --platform linux/amd64,linux/arm64,linux/s390x,linux/ppc64le . -f docker/mongodb-kubernetes-operator/Dockerfile -t "${BASE_REPO_URL}mongodb-kubernetes:${VERSION}" \
  --build-arg version="${VERSION}" \
  --build-arg log_automation_config_diff="${LOG_AUTOMATION_CONFIG_DIFF}" \
  --build-arg use_race="${USE_RACE}"
+
+docker push "${BASE_REPO_URL}mongodb-kubernetes:${VERSION}"
 ```
 
 ### Running locally
diff --git a/docker/mongodb-kubernetes-readinessprobe/Dockerfile b/docker/mongodb-kubernetes-readinessprobe/Dockerfile
index a2f3159b4..55d661438 100644
--- a/docker/mongodb-kubernetes-readinessprobe/Dockerfile
+++ b/docker/mongodb-kubernetes-readinessprobe/Dockerfile
@@ -1,10 +1,16 @@
-FROM public.ecr.aws/docker/library/golang:1.24 AS builder
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.24 AS builder
 
-WORKDIR /go/src
-ADD . .
+WORKDIR /go/src/github.com/mongodb/mongodb-kubernetes/
 
+COPY go.mod go.sum ./
+
+RUN go mod download
+
+COPY mongodb-community-operator /go/src/github.com/mongodb/mongodb-kubernetes/mongodb-community-operator
+
+ARG TARGETOS
 ARG TARGETARCH
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=${TARGETARCH} go build -a -o /data/scripts/readinessprobe ./mongodb-community-operator/cmd/readiness/main.go
+RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -a -o /data/scripts/readinessprobe ./mongodb-community-operator/cmd/readiness/main.go
 
 FROM registry.access.redhat.com/ubi9/ubi-minimal
 
diff --git a/docker/mongodb-kubernetes-tests/Dockerfile b/docker/mongodb-kubernetes-tests/Dockerfile
index 424f5ee76..5347a8f19 100644
--- a/docker/mongodb-kubernetes-tests/Dockerfile
+++ b/docker/mongodb-kubernetes-tests/Dockerfile
@@ -8,19 +8,37 @@
 #
 ARG PYTHON_VERSION
 
-FROM --platform=linux/amd64 public.ecr.aws/docker/library/python:${PYTHON_VERSION}-slim as builder
-
+FROM public.ecr.aws/docker/library/python:${PYTHON_VERSION}-slim as builder
 
 RUN apt-get -qq update \
     && apt-get -y -qq install \
-    curl libldap2-dev libsasl2-dev build-essential git
+    curl libldap2-dev libsasl2-dev build-essential git libssl-dev pkg-config
 
 COPY requirements.txt requirements.txt
 
-RUN python3 -m venv /venv && . /venv/bin/activate && python3 -m pip install -r requirements.txt
+RUN python3 -m venv /venv && . /venv/bin/activate && pip install --upgrade pip && GRPC_PYTHON_BUILD_SYSTEM_OPENSSL=1 pip install -r requirements.txt
+
+FROM scratch AS tools_downloader
+
+ARG mongodb_tools_url="https://fastdl.mongodb.org/tools/db"
+
+ARG mongodb_tools_version_amd64="mongodb-database-tools-rhel93-x86_64-100.12.0.tgz"
+ADD "${mongodb_tools_url}/${mongodb_tools_version_amd64}" /data/amd64/mongodb_tools.tgz
+
+ARG mongodb_tools_version_arm64="mongodb-database-tools-rhel93-aarch64-100.12.0.tgz"
+ADD "${mongodb_tools_url}/${mongodb_tools_version_arm64}" /data/arm64/mongodb_tools.tgz
 
+ARG mongodb_tools_version_s390x="mongodb-database-tools-rhel9-s390x-100.12.0.tgz"
+ADD "${mongodb_tools_url}/${mongodb_tools_version_s390x}" /data/s390x/mongodb_tools.tgz
 
-FROM --platform=linux/amd64 public.ecr.aws/docker/library/python:${PYTHON_VERSION}-slim
+ARG mongodb_tools_version_ppc64le="mongodb-database-tools-rhel9-ppc64le-100.12.0.tgz"
+ADD "${mongodb_tools_url}/${mongodb_tools_version_ppc64le}" /data/ppc64le/mongodb_tools.tgz
+
+
+FROM public.ecr.aws/docker/library/python:${PYTHON_VERSION}-slim
+
+ARG TARGETARCH
+COPY --from=tools_downloader "/data/${TARGETARCH}/mongodb_tools.tgz" /tmp/mongodb-tools.tgz
 
 RUN apt-get -qq update \
     && apt-get -y -qq install \
@@ -30,20 +48,22 @@ RUN apt-get -qq update \
     git \
     openssl
 
-ENV HELM_NAME "helm-v3.17.1-linux-amd64.tar.gz"
-# install Helm
-RUN curl --fail --retry 3 -L -o "${HELM_NAME}" "https://get.helm.sh/${HELM_NAME}" \
-    && tar -xzf "${HELM_NAME}" \
-    && rm "${HELM_NAME}" \
-    && mv "linux-amd64/helm" "/usr/local/bin/helm"
-
-ADD https://fastdl.mongodb.org/tools/db/mongodb-database-tools-ubuntu2204-x86_64-100.12.0.tgz /tmp/mongodb-tools.tgz
 RUN mkdir -p /tmp/mongodb-tools && \
     tar xfz /tmp/mongodb-tools.tgz -C /tmp/mongodb-tools && \
     cp /tmp/mongodb-tools/*/bin/* /usr/local/bin/ && \
     rm -rf /tmp/mongodb-tools /tmp/mongodb-tools.tgz
 
-RUN curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl" \
+
+ENV HELM_NAME "helm-v3.17.1-linux-${TARGETARCH}.tar.gz"
+
+# install Helm
+RUN curl --fail --retry 3 -L -o "${HELM_NAME}" "https://get.helm.sh/${HELM_NAME}" \
+    && tar -xzf "${HELM_NAME}" \
+    && rm "${HELM_NAME}" \
+    && mv "linux-${TARGETARCH}/helm" "/usr/local/bin/helm"
+
+# install kubectl
+RUN curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/${TARGETARCH}/kubectl" \
     && chmod +x ./kubectl \
     && mv ./kubectl /usr/local/bin/kubectl
 
@@ -62,4 +82,4 @@ COPY release.json /release.json
 # we use the public directory to automatically test resources samples
 COPY public /mongodb-kubernetes/public
 
-ADD multi-cluster-kube-config-creator_linux /usr/local/bin/multi-cluster-kube-config-creator
+ADD "multi-cluster-kube-config-creator_${TARGETARCH}" /usr/local/bin/multi-cluster-kube-config-creator
diff --git a/docker/mongodb-kubernetes-tests/README.md b/docker/mongodb-kubernetes-tests/README.md
index dec9ac764..e09b77a0e 100644
--- a/docker/mongodb-kubernetes-tests/README.md
+++ b/docker/mongodb-kubernetes-tests/README.md
@@ -106,6 +106,18 @@ indicate which test classes need to be run. But for now they help us
 to call a particular E2E task we are interested in.
 
 
+## Building test image
+
+```bash
+make prepare-local-e2e
+cd docker/mongodb-kubernetes-tests
+BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa/"
+docker buildx build --progress plain --platform linux/amd64,linux/arm64,linux/s390x,linux/ppc64le . -f Dockerfile -t "${BASE_REPO_URL}mongodb-kubernetes-tests:evergreen" \
+ --build-arg PYTHON_VERSION="3.13"
+
+docker push "${BASE_REPO_URL}mongodb-kubernetes-tests:evergreen"
+```
+
 # Writing New Tests #
 
 ### Create a new Python test file ###
diff --git a/docker/mongodb-kubernetes-upgrade-hook/Dockerfile b/docker/mongodb-kubernetes-upgrade-hook/Dockerfile
index 5005f5801..fab594d5e 100644
--- a/docker/mongodb-kubernetes-upgrade-hook/Dockerfile
+++ b/docker/mongodb-kubernetes-upgrade-hook/Dockerfile
@@ -1,10 +1,16 @@
-FROM public.ecr.aws/docker/library/golang:1.24 AS builder
+FROM --platform=$BUILDPLATFORM public.ecr.aws/docker/library/golang:1.24 AS builder
 
-WORKDIR /go/src
-ADD . .
+WORKDIR /go/src/github.com/mongodb/mongodb-kubernetes/
+
+COPY go.mod go.sum ./
+
+RUN go mod download
+
+COPY mongodb-community-operator /go/src/github.com/mongodb/mongodb-kubernetes/mongodb-community-operator
 
 ARG TARGETARCH
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=${TARGETARCH} go build -a -o /data/scripts/version-upgrade-hook ./mongodb-community-operator/cmd/versionhook/main.go
+ARG TARGETOS
+RUN CGO_ENABLED=0 GOOS=${TARGETOS} GOARCH=${TARGETARCH} go build -a -o /data/scripts/version-upgrade-hook ./mongodb-community-operator/cmd/versionhook/main.go
 
 FROM registry.access.redhat.com/ubi9/ubi-minimal
 
diff --git a/scripts/dev/configure_docker_auth.sh b/scripts/dev/configure_docker_auth.sh
index dfcb14f0b..7647fa8a4 100755
--- a/scripts/dev/configure_docker_auth.sh
+++ b/scripts/dev/configure_docker_auth.sh
@@ -8,7 +8,81 @@ source scripts/funcs/checks
 source scripts/funcs/printing
 source scripts/funcs/kubernetes
 
+# Parse command line arguments
+CONTAINER_RUNTIME="${CONTAINER_RUNTIME-"docker"}"
+
+# Validate and set up container runtime configuration
+setup_container_runtime() {
+  case "${CONTAINER_RUNTIME}" in
+    "podman")
+      if ! command -v podman &> /dev/null; then
+        echo "Error: Podman is not available but was specified"
+        exit 1
+      fi
+      USE_SUDO=true
+      CONFIG_PATH="/root/.config/containers/auth.json"
+      echo "Using Podman for container authentication (sudo mode)"
+      ;;
+    "docker")
+      if ! command -v docker &> /dev/null; then
+        echo "Error: Docker is not available but was specified"
+        exit 1
+      fi
+      USE_SUDO=false
+      CONFIG_PATH="${HOME}/.docker/config.json"
+      echo "Using Docker for container authentication"
+      ;;
+    *)
+      echo "Error: Invalid container runtime '${CONTAINER_RUNTIME}'. Must be 'docker' or 'podman'"
+      exit 1
+      ;;
+  esac
+
+  # Create config directory
+  if [[ "$USE_SUDO" == "true" ]]; then
+    sudo mkdir -p "$(dirname "${CONFIG_PATH}")"
+  else
+    mkdir -p "$(dirname "${CONFIG_PATH}")"
+  fi
+}
+
+# Wrapper function to execute commands with or without sudo
+exec_cmd() {
+  if [[ "$USE_SUDO" == "true" ]]; then
+    sudo env PATH="$PATH" "$@"
+  else
+    "$@"
+  fi
+}
+
+# Wrapper function to read files with or without sudo
+read_file() {
+  local file="$1"
+  if [[ "$USE_SUDO" == "true" ]]; then
+    sudo cat "$file"
+  else
+    cat "$file"
+  fi
+}
+
+# Wrapper function to write files with or without sudo
+write_file() {
+  local content="$1"
+  local file="$2"
+  if [[ "$USE_SUDO" == "true" ]]; then
+    echo "$content" | sudo tee "$file" > /dev/null
+  else
+    echo "$content" > "$file"
+  fi
+}
+
 check_docker_daemon_is_running() {
+  if [[ "${CONTAINER_RUNTIME}" == "podman" ]]; then
+    # Podman doesn't require a daemon
+    echo "Using Podman (no daemon required)"
+    return 0
+  fi
+
   if [[ "$(uname -s)" != "Linux" ]]; then
     echo "Skipping docker daemon check when not running in Linux"
     return 0
@@ -32,73 +106,102 @@ check_docker_daemon_is_running() {
 }
 
 remove_element() {
-  config_option="${1}"
-  tmpfile=$(mktemp)
-  jq 'del(.'"${config_option}"')' ~/.docker/config.json >"${tmpfile}"
-  cp "${tmpfile}" ~/.docker/config.json
+  local config_option="$1"
+  local tmpfile=$(mktemp)
+
+  # Initialize config file if it doesn't exist
+  if [[ ! -f "${CONFIG_PATH}" ]]; then
+    write_file '{}' "${CONFIG_PATH}"
+  fi
+
+  # Remove the specified element using jq
+  exec_cmd jq 'del(.'"${config_option}"')' "${CONFIG_PATH}" > "${tmpfile}"
+  exec_cmd cp "${tmpfile}" "${CONFIG_PATH}"
   rm "${tmpfile}"
 }
 
-# This is the script which performs docker authentication to different registries that we use (so far ECR and RedHat)
-# As the result of this login the ~/.docker/config.json will have all the 'auth' information necessary to work with docker registries
+# Container runtime login wrapper
+container_login() {
+  local username="$1"
+  local registry="$2"
+
+  if [[ "${CONTAINER_RUNTIME}" == "podman" ]]; then
+    exec_cmd podman login --authfile "${CONFIG_PATH}" --username "${username}" --password-stdin "${registry}"
+  else
+    docker login --username "${username}" --password-stdin "${registry}"
+  fi
+}
+
+# This is the script which performs container authentication to different registries that we use (so far ECR and RedHat)
+# As the result of this login the config file will have all the 'auth' information necessary to work with container registries
+
+setup_container_runtime
 
 check_docker_daemon_is_running
 
-if [[ -f ~/.docker/config.json ]]; then
+# Initialize config file if it doesn't exist
+if [[ ! -f "${CONFIG_PATH}" ]]; then
+  write_file '{}' "${CONFIG_PATH}"
+fi
+
+if [[ -f "${CONFIG_PATH}" ]]; then
   if [[ "${RUNNING_IN_EVG:-"false"}" != "true" ]]; then
-    # Check if login is actually required by making a HEAD request to ECR using existing Docker config
-    echo "Checking if Docker credentials are valid..."
-    ecr_auth=$(jq -r '.auths."268558157000.dkr.ecr.us-east-1.amazonaws.com".auth // empty' ~/.docker/config.json)
+    # Check if login is actually required by making a HEAD request to ECR using existing credentials
+    echo "Checking if container registry credentials are valid..."
+    ecr_auth=$(exec_cmd jq -r '.auths."268558157000.dkr.ecr.us-east-1.amazonaws.com".auth // empty' "${CONFIG_PATH}")
 
     if [[ -n "${ecr_auth}" ]]; then
       http_status=$(curl --head -s -o /dev/null -w "%{http_code}" --max-time 3 "https://268558157000.dkr.ecr.us-east-1.amazonaws.com/v2/dev/mongodb-kubernetes/manifests/latest" \
         -H "Authorization: Basic ${ecr_auth}" 2>/dev/null || echo "error/timeout")
 
       if [[ "${http_status}" != "401" && "${http_status}" != "403" && "${http_status}" != "error/timeout" ]]; then
-        echo "Docker credentials are up to date - not performing the new login!"
+        echo "Container registry credentials are up to date - not performing the new login!"
         exit
       fi
-      echo "Docker login required (HTTP status: ${http_status})"
+      echo "Container login required (HTTP status: ${http_status})"
     else
-      echo "No ECR credentials found in Docker config - login required"
+      echo "No ECR credentials found in container config - login required"
     fi
   fi
 
-  title "Performing docker login to ECR registries"
+  title "Performing container login to ECR registries"
 
-  # There could be some leftovers on Evergreen
-  if grep -q "credsStore" ~/.docker/config.json; then
-    remove_element "credsStore"
-  fi
-  if grep -q "credHelpers" ~/.docker/config.json; then
-    remove_element "credHelpers"
+  # There could be some leftovers on Evergreen (Docker-specific, skip for Podman)
+  if [[ "${CONTAINER_RUNTIME}" == "docker" ]]; then
+    if exec_cmd grep -q "credsStore" "${CONFIG_PATH}"; then
+      remove_element "credsStore"
+    fi
+    if exec_cmd grep -q "credHelpers" "${CONFIG_PATH}"; then
+      remove_element "credHelpers"
+    fi
   fi
 fi
 
 
 echo "$(aws --version)}"
 
-aws ecr get-login-password --region "us-east-1" | docker login --username AWS --password-stdin 268558157000.dkr.ecr.us-east-1.amazonaws.com
+aws ecr get-login-password --region "us-east-1" | container_login "AWS" "268558157000.dkr.ecr.us-east-1.amazonaws.com"
 
 # by default docker tries to store credentials in an external storage (e.g. OS keychain) - not in the config.json
 # We need to store it as base64 string in config.json instead so we need to remove the "credsStore" element
-if grep -q "credsStore" ~/.docker/config.json; then
+# This is Docker-specific behavior, Podman stores credentials directly in auth.json
+if [[ "${CONTAINER_RUNTIME}" == "docker" ]] && exec_cmd grep -q "credsStore" "${CONFIG_PATH}"; then
   remove_element "credsStore"
 
   # login again to store the credentials into the config.json
-  aws ecr get-login-password --region "us-east-1" | docker login --username AWS --password-stdin 268558157000.dkr.ecr.us-east-1.amazonaws.com
+  aws ecr get-login-password --region "us-east-1" | container_login "AWS" "268558157000.dkr.ecr.us-east-1.amazonaws.com"
 fi
 
-aws ecr get-login-password --region "eu-west-1" | docker login --username AWS --password-stdin 268558157000.dkr.ecr.eu-west-1.amazonaws.com
+aws ecr get-login-password --region "eu-west-1" | container_login "AWS" "268558157000.dkr.ecr.eu-west-1.amazonaws.com"
 
 if [[ -n "${COMMUNITY_PRIVATE_PREVIEW_PULLSECRET_DOCKERCONFIGJSON:-}" ]]; then
   # log in to quay.io for the mongodb/mongodb-search-community private repo
   # TODO remove once we switch to the official repo in Public Preview
   quay_io_auth_file=$(mktemp)
-  docker_configjson_tmp=$(mktemp)
+  config_tmp=$(mktemp)
   echo "${COMMUNITY_PRIVATE_PREVIEW_PULLSECRET_DOCKERCONFIGJSON}" | base64 -d > "${quay_io_auth_file}"
-  jq -s '.[0] * .[1]' "${quay_io_auth_file}" ~/.docker/config.json > "${docker_configjson_tmp}"
-  mv "${docker_configjson_tmp}" ~/.docker/config.json
+  exec_cmd jq -s '.[0] * .[1]' "${quay_io_auth_file}" "${CONFIG_PATH}" > "${config_tmp}"
+  exec_cmd mv "${config_tmp}" "${CONFIG_PATH}"
   rm "${quay_io_auth_file}"
 fi
 
diff --git a/scripts/dev/contexts/e2e_smoke_arm b/scripts/dev/contexts/e2e_smoke_arm
new file mode 100644
index 000000000..64568ed5b
--- /dev/null
+++ b/scripts/dev/contexts/e2e_smoke_arm
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+set -Eeou pipefail
+
+script_name=$(readlink -f "${BASH_SOURCE[0]}")
+script_dir=$(dirname "${script_name}")
+
+source "${script_dir}/root-context"
+
+export ops_manager_version="cloud_qa"
+
+# This is required to be able to rebuild the om image and use that image which has been rebuild
+export OPS_MANAGER_REGISTRY=268558157000.dkr.ecr.us-east-1.amazonaws.com/dev
+CUSTOM_OM_VERSION=$(grep -E "^\s*-\s*&ops_manager_70_latest\s+(\S+)\s+#" <"${script_dir}"/../../../.evergreen.yml | awk '{print $3}')
+export CUSTOM_OM_VERSION
+
+export CUSTOM_MDB_VERSION=6.0.5-ent
+export CUSTOM_MDB_PREV_VERSION=5.0.7-ent
+export KUBE_ENVIRONMENT_NAME=kind
+export CLUSTER_TYPE=kind
+
+
+# TODO: change once we have image building
+export BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa"
+export REGISTRY="${BASE_REPO_URL}"
+export INIT_DATABASE_IMAGE_REPOSITORY="${BASE_REPO_URL}/mongodb-kubernetes-init-database"
+export OPERATOR_REGISTRY=${BASE_REPO_URL}
+export DATABASE_REGISTRY=${BASE_REPO_URL}
+export INIT_DATABASE_REGISTRY=${BASE_REPO_URL}
+
diff --git a/scripts/dev/contexts/e2e_smoke_ibm_power b/scripts/dev/contexts/e2e_smoke_ibm_power
new file mode 100644
index 000000000..2b1000cb6
--- /dev/null
+++ b/scripts/dev/contexts/e2e_smoke_ibm_power
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+set -Eeou pipefail
+
+script_name=$(readlink -f "${BASH_SOURCE[0]}")
+script_dir=$(dirname "${script_name}")
+
+source "${script_dir}/root-context"
+
+export ops_manager_version="cloud_qa"
+
+# This is required to be able to rebuild the om image and use that image which has been rebuild
+export OPS_MANAGER_REGISTRY=268558157000.dkr.ecr.us-east-1.amazonaws.com/dev
+CUSTOM_OM_VERSION=$(grep -E "^\s*-\s*&ops_manager_70_latest\s+(\S+)\s+#" <"${script_dir}"/../../../.evergreen.yml | awk '{print $3}')
+export CUSTOM_OM_VERSION
+
+export CUSTOM_MDB_VERSION=6.0.5-ent
+export CUSTOM_MDB_PREV_VERSION=5.0.7-ent
+export KUBE_ENVIRONMENT_NAME=minikube
+export CLUSTER_TYPE=minikube
+export CONTAINER_RUNTIME=podman
+
+# TODO: change once we have image building
+export BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa"
+export REGISTRY="${BASE_REPO_URL}"
+export INIT_DATABASE_IMAGE_REPOSITORY="${BASE_REPO_URL}/mongodb-kubernetes-init-database"
+export OPERATOR_REGISTRY=${BASE_REPO_URL}
+export DATABASE_REGISTRY=${BASE_REPO_URL}
+export INIT_DATABASE_REGISTRY=${BASE_REPO_URL}
+
diff --git a/scripts/dev/contexts/e2e_smoke_ibm_z b/scripts/dev/contexts/e2e_smoke_ibm_z
new file mode 100644
index 000000000..2b1000cb6
--- /dev/null
+++ b/scripts/dev/contexts/e2e_smoke_ibm_z
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+set -Eeou pipefail
+
+script_name=$(readlink -f "${BASH_SOURCE[0]}")
+script_dir=$(dirname "${script_name}")
+
+source "${script_dir}/root-context"
+
+export ops_manager_version="cloud_qa"
+
+# This is required to be able to rebuild the om image and use that image which has been rebuild
+export OPS_MANAGER_REGISTRY=268558157000.dkr.ecr.us-east-1.amazonaws.com/dev
+CUSTOM_OM_VERSION=$(grep -E "^\s*-\s*&ops_manager_70_latest\s+(\S+)\s+#" <"${script_dir}"/../../../.evergreen.yml | awk '{print $3}')
+export CUSTOM_OM_VERSION
+
+export CUSTOM_MDB_VERSION=6.0.5-ent
+export CUSTOM_MDB_PREV_VERSION=5.0.7-ent
+export KUBE_ENVIRONMENT_NAME=minikube
+export CLUSTER_TYPE=minikube
+export CONTAINER_RUNTIME=podman
+
+# TODO: change once we have image building
+export BASE_REPO_URL="268558157000.dkr.ecr.us-east-1.amazonaws.com/lucian.tosa"
+export REGISTRY="${BASE_REPO_URL}"
+export INIT_DATABASE_IMAGE_REPOSITORY="${BASE_REPO_URL}/mongodb-kubernetes-init-database"
+export OPERATOR_REGISTRY=${BASE_REPO_URL}
+export DATABASE_REGISTRY=${BASE_REPO_URL}
+export INIT_DATABASE_REGISTRY=${BASE_REPO_URL}
+
diff --git a/scripts/dev/install_csi_driver.sh b/scripts/dev/install_csi_driver.sh
index 85d365535..d9b3fccc5 100755
--- a/scripts/dev/install_csi_driver.sh
+++ b/scripts/dev/install_csi_driver.sh
@@ -2,6 +2,7 @@
 
 set -Eeou pipefail
 
+source scripts/dev/set_env_context.sh
 source scripts/funcs/kubernetes
 
 # Path to the deploy script
diff --git a/scripts/dev/prepare_local_e2e_run.sh b/scripts/dev/prepare_local_e2e_run.sh
index 6bac19df1..2139b894b 100755
--- a/scripts/dev/prepare_local_e2e_run.sh
+++ b/scripts/dev/prepare_local_e2e_run.sh
@@ -60,6 +60,11 @@ prepare_operator_config_map "$(kubectl config current-context)" 2>&1 | prepend "
 rm -rf docker/mongodb-kubernetes-tests/helm_chart
 cp -rf helm_chart docker/mongodb-kubernetes-tests/helm_chart
 
+rm -rf docker/mongodb-kubernetes-tests/public
+cp -rf public docker/mongodb-kubernetes-tests/public
+cp release.json docker/mongodb-kubernetes-tests/release.json
+cp requirements.txt docker/mongodb-kubernetes-tests/requirements.txt
+
 # shellcheck disable=SC2154
 if [[ "${KUBE_ENVIRONMENT_NAME}" == "multi" ]]; then
   prepare_multi_cluster_e2e_run 2>&1 | prepend "prepare_multi_cluster_e2e_run"
diff --git a/scripts/dev/recreate_python_venv.sh b/scripts/dev/recreate_python_venv.sh
index fb1f9ab8f..6594b3fb2 100755
--- a/scripts/dev/recreate_python_venv.sh
+++ b/scripts/dev/recreate_python_venv.sh
@@ -6,24 +6,109 @@ set -Eeou pipefail
 
 source scripts/dev/set_env_context.sh
 
+install_pyenv() {
+    # Check if pyenv directory exists first
+    if [[ -d "${HOME}/.pyenv" ]]; then
+        echo "pyenv directory already exists, setting up environment..." >&2
+        export PYENV_ROOT="${HOME}/.pyenv"
+        export PATH="${PYENV_ROOT}/bin:${PATH}"
+        
+        # Initialize pyenv in current shell
+        if command -v pyenv &> /dev/null; then
+            eval "$(pyenv init --path)"
+            eval "$(pyenv init -)"
+            echo "pyenv already installed and initialized" >&2
+            return 0
+        else
+            echo "pyenv directory exists but binary not working, reinstalling..." >&2
+            rm -rf "${HOME}/.pyenv"
+        fi
+    fi
+    
+    # Check if pyenv command is available in PATH
+    if command -v pyenv &> /dev/null; then
+        echo "pyenv already available in PATH" >&2
+        return 0
+    fi
+
+    echo "Installing pyenv..." >&2
+
+    # Install pyenv via the official installer
+    if curl -s -S -L https://raw.githubusercontent.com/pyenv/pyenv-installer/master/bin/pyenv-installer | bash; then
+        # Add pyenv to PATH for current session
+        export PYENV_ROOT="${HOME}/.pyenv"
+        export PATH="${PYENV_ROOT}/bin:${PATH}"
+
+        # Initialize pyenv in current shell
+        if command -v pyenv &> /dev/null; then
+            eval "$(pyenv init --path)"
+            eval "$(pyenv init -)"
+        fi
+
+        echo "pyenv installed successfully" >&2
+        return 0
+    else
+        echo "Failed to install pyenv" >&2
+        return 1
+    fi
+}
+
+ensure_required_python() {
+    local required_version="${PYTHON_VERSION:-3.13}"
+    local major_minor
+    major_minor=$(echo "${required_version}" | grep -oE '^[0-9]+\.[0-9]+')
+
+    echo "Setting up Python ${required_version} (${major_minor}.x)..." >&2
+
+    # Always install pyenv first
+    if ! install_pyenv; then
+        echo "Error: Failed to install pyenv" >&2
+        return 1
+    fi
+
+    # Install latest version in the required series
+    local latest_version
+    latest_version=$(pyenv install --list | grep -E "^[[:space:]]*${major_minor}\.[0-9]+$" | tail -1 | xargs)
+    if [[ -n "${latest_version}" ]]; then
+        echo "Installing Python ${latest_version} via pyenv..." >&2
+        # Use --skip-existing to avoid errors if version already exists
+        if pyenv install --skip-existing "${latest_version}"; then
+            pyenv global "${latest_version}"
+            # Install python3-venv package for Debian/Ubuntu systems if needed
+            if command -v apt-get &> /dev/null; then
+                echo "Installing python3-venv package for venv support..." >&2
+                sudo apt-get update -qq && sudo apt-get install -y python3-venv || true
+            fi
+            return 0
+        fi
+    fi
+
+    echo "Error: Unable to install Python ${major_minor} via pyenv" >&2
+    return 1
+}
+
 if [[ -d "${PROJECT_DIR}"/venv ]]; then
   echo "Removing venv..."
   cd "${PROJECT_DIR}"
   rm -rf "venv"
 fi
 
-# in our EVG hosts, python versions are always in /opt/python
-python_bin="/opt/python/${PYTHON_VERSION}/bin/python3"
-if [[ "$(uname)" == "Darwin" ]]; then
-  python_bin="python${PYTHON_VERSION}"
-fi
-
-echo "Using python from the following path: ${python_bin}"
+# Ensure required Python version is available
+ensure_required_python
 
-"${python_bin}" -m venv venv
+python3 -m venv venv
 source venv/bin/activate
 pip install --upgrade pip
-pip install -r requirements.txt
+
+skip_requirements="${SKIP_INSTALL_REQUIREMENTS:-false}"
+if [[ "${skip_requirements}" != "true" ]]; then
+    echo "Installing requirements.txt..."
+    pip install -r requirements.txt
+else
+    echo "Skipping requirements.txt installation."
+    pip install requests
+fi
+
 echo "Python venv was recreated successfully."
 echo "Current python path: $(which python)"
 python --version
diff --git a/scripts/dev/reset_helm.sh b/scripts/dev/reset_helm.sh
index 080cbffb1..15280c56f 100755
--- a/scripts/dev/reset_helm.sh
+++ b/scripts/dev/reset_helm.sh
@@ -1,5 +1,7 @@
 #!/bin/bash
 
+source scripts/dev/set_env_context.sh
+
 # Set Helm release name
 HELM_RELEASE="mongodb-kubernetes-operator"
 
diff --git a/scripts/dev/switch_context.sh b/scripts/dev/switch_context.sh
index 5d07e8fff..e5b25c4e4 100755
--- a/scripts/dev/switch_context.sh
+++ b/scripts/dev/switch_context.sh
@@ -99,17 +99,23 @@ echo "Generated env files in $(readlink -f "${destination_envs_dir}"):"
 # shellcheck disable=SC2010
 ls -l1 "${destination_envs_dir}" | grep "context"
 
-if which kubectl > /dev/null; then
+# Prefer kubectl from bin directory if it exists, otherwise use system kubectl
+KUBECTL_CMD="kubectl"
+if [[ -n "${PROJECT_DIR:-}" && -x "${PROJECT_DIR}/bin/kubectl" ]]; then
+    KUBECTL_CMD="${PROJECT_DIR}/bin/kubectl"
+fi
+
+if [[ "$KUBECTL_CMD" != "kubectl" ]] || which kubectl > /dev/null; then
     if [ "${CLUSTER_NAME-}" ]; then
         # The convention: the cluster name must match the name of kubectl context
         # We expect this not to be true if kubernetes cluster is still to be created (minikube/kops)
-        if ! kubectl config use-context "${CLUSTER_NAME}"; then
+        if ! "$KUBECTL_CMD" config use-context "${CLUSTER_NAME}"; then
             echo "Warning: failed to switch kubectl context to: ${CLUSTER_NAME}"
             echo "Does a matching Kubernetes context exist?"
         fi
 
         # Setting the default namespace for current context
-        kubectl config set-context "$(kubectl config current-context)" "--namespace=${NAMESPACE}" &>/dev/null || true
+        "$KUBECTL_CMD" config set-context "$("$KUBECTL_CMD" config current-context)" "--namespace=${NAMESPACE}" &>/dev/null || true
 
         # shellcheck disable=SC2153
         echo "Current context: ${context} (kubectl context: ${CLUSTER_NAME}), namespace=${NAMESPACE}"
diff --git a/scripts/evergreen/build_multi_cluster_kubeconfig_creator.sh b/scripts/evergreen/build_multi_cluster_kubeconfig_creator.sh
index f8bbf1890..63729d024 100755
--- a/scripts/evergreen/build_multi_cluster_kubeconfig_creator.sh
+++ b/scripts/evergreen/build_multi_cluster_kubeconfig_creator.sh
@@ -16,14 +16,21 @@ echo "Building multi cluster kube config creation tool."
 
 project_dir="$(pwd)"
 pushd cmd/kubectl-mongodb
-GOOS="${OS}" GOARCH="${ARCH}" CGO_ENABLED=0 go build -buildvcs=false -o "${project_dir}/docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator" main.go
-GOOS="linux" GOARCH="amd64" CGO_ENABLED=0 go build -buildvcs=false -o "${project_dir}/docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_linux" main.go
+GOOS="${OS}" GOARCH="${ARCH}" CGO_ENABLED=0 go build -buildvcs=false -o "${project_dir}/docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator" main.go &
+
+GOOS="linux" GOARCH="amd64" CGO_ENABLED=0 go build -buildvcs=false -o "${project_dir}/docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_amd64" main.go &
+GOOS="linux" GOARCH="s390x" CGO_ENABLED=0 go build -buildvcs=false -o "${project_dir}/docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_s390x" main.go &
+GOOS="linux" GOARCH="ppc64le" CGO_ENABLED=0 go build -buildvcs=false -o "${project_dir}/docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_ppc64le" main.go &
+GOOS="linux" GOARCH="arm64" CGO_ENABLED=0 go build -buildvcs=false -o "${project_dir}/docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_arm64" main.go &
+wait
 popd
 chmod +x docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator
 
-# this one is used for the dockerfile to build the test image running on linux, this script might create 2 times
-# the same binary, but on the average case it creates one for linux and one for darwin-arm
-chmod +x docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_linux
+# these are used in the dockerfile
+chmod +x docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_amd64
+chmod +x docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_s390x
+chmod +x docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_ppc64le
+chmod +x docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator_arm64
 
 mkdir -p bin || true
 cp docker/mongodb-kubernetes-tests/multi-cluster-kube-config-creator bin/kubectl-mongodb || true
diff --git a/scripts/evergreen/deployments/test-app/templates/mongodb-enterprise-tests.yaml b/scripts/evergreen/deployments/test-app/templates/mongodb-enterprise-tests.yaml
index 67661b29b..0b6e72b1b 100644
--- a/scripts/evergreen/deployments/test-app/templates/mongodb-enterprise-tests.yaml
+++ b/scripts/evergreen/deployments/test-app/templates/mongodb-enterprise-tests.yaml
@@ -53,9 +53,9 @@ spec:
         secretName: test-pod-multi-cluster-config
   {{ end }}
   containers:
-  - image: busybox
+  - image: public.ecr.aws/docker/library/busybox:1.37.0
     name: keepalive
-    command: [ "/bin/sh", "-c", "sleep inf" ]
+    command: ["/bin/sh", "-c", "while true; do sleep 3600; done"]
     volumeMounts:
       - name: results
         mountPath: /tmp/results
diff --git a/scripts/evergreen/e2e/single_e2e.sh b/scripts/evergreen/e2e/single_e2e.sh
index dbb1306da..1adb8476c 100755
--- a/scripts/evergreen/e2e/single_e2e.sh
+++ b/scripts/evergreen/e2e/single_e2e.sh
@@ -213,8 +213,8 @@ run_tests() {
     echo
 
     # We need to make sure to access this file after the test has finished
-    kubectl --context "${test_pod_context}" -n "${NAMESPACE}" cp "${TEST_APP_PODNAME}":/tmp/results/myreport.xml logs/myreport.xml
-    kubectl --context "${test_pod_context}" -n "${NAMESPACE}" cp "${TEST_APP_PODNAME}":/tmp/diagnostics logs
+    kubectl --context "${test_pod_context}" -n "${NAMESPACE}" -c keepalive cp "${TEST_APP_PODNAME}":/tmp/results/myreport.xml logs/myreport.xml
+    kubectl --context "${test_pod_context}" -n "${NAMESPACE}" -c keepalive cp "${TEST_APP_PODNAME}":/tmp/diagnostics logs
 
     status="$(kubectl --context "${test_pod_context}" get pod "${TEST_APP_PODNAME}" -n "${NAMESPACE}" -o jsonpath="{ .status }" | jq -r '.containerStatuses[] | select(.name == "mongodb-enterprise-operator-tests")'.state.terminated.reason)"
     [[ "${status}" == "Completed" ]]
diff --git a/scripts/evergreen/setup_aws.sh b/scripts/evergreen/setup_aws.sh
index 931eb0a36..5563a8a30 100755
--- a/scripts/evergreen/setup_aws.sh
+++ b/scripts/evergreen/setup_aws.sh
@@ -3,16 +3,116 @@ set -Eeou pipefail
 
 source scripts/dev/set_env_context.sh
 
-INSTALL_DIR="${workdir:?}/.local/lib/aws"
-BIN_LOCATION="${workdir}/bin"
+# Detect system architecture
+detect_architecture() {
+    local arch
+    arch=$(uname -m)
+    echo "Detected architecture: ${arch}" >&2
+    echo "${arch}"
+}
 
-mkdir -p "${BIN_LOCATION}"
+# Install AWS CLI v2 via binary download (for x86_64 and aarch64)
+install_aws_cli_binary() {
+    local arch="$1"
+    echo "Installing AWS CLI v2 via binary download for ${arch}..."
 
-tmpdir=$(mktemp -d)
-cd "${tmpdir}"
+    # Map architecture names for AWS CLI download URLs
+    local aws_arch
+    case "${arch}" in
+        x86_64)
+            aws_arch="x86_64"
+            ;;
+        aarch64|arm64)
+            aws_arch="aarch64"
+            ;;
+        *)
+            echo "Error: Unsupported architecture for binary installation: ${arch}" >&2
+            return 1
+            ;;
+    esac
 
-curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
-unzip awscliv2.zip &> /dev/null
+    # Download and install AWS CLI v2
+    local temp_dir
+    temp_dir=$(mktemp -d)
+    cd "${temp_dir}"
+
+    echo "Downloading AWS CLI v2 for ${aws_arch}..."
+    curl -s "https://awscli.amazonaws.com/awscli-exe-linux-${aws_arch}.zip" -o "awscliv2.zip"
+    
+    unzip -q awscliv2.zip
+    sudo ./aws/install --update
+
+    # Clean up
+    cd - > /dev/null
+    rm -rf "${temp_dir}"
+
+    # Verify installation
+    if command -v aws &> /dev/null; then
+        echo "AWS CLI v2 installed successfully:"
+        aws --version
+    else
+        echo "Error: AWS CLI v2 installation failed" >&2
+        return 1
+    fi
+}
+
+# Install AWS CLI v1 via pip (for IBM architectures: ppc64le, s390x)
+install_aws_cli_pip() {
+    echo "Installing AWS CLI v1 via pip (for IBM architectures)..."
+
+    # Ensure pip is available
+    if ! command -v pip3 &> /dev/null && ! command -v pip &> /dev/null; then
+        echo "Error: pip is not available. Please install Python and pip first." >&2
+        return 1
+    fi
+
+    # Use pip3 if available, otherwise pip
+    local pip_cmd="pip3"
+    if ! command -v pip3 &> /dev/null; then
+        pip_cmd="pip"
+    fi
+
+    echo "Installing AWS CLI using ${pip_cmd}..."
+    ${pip_cmd} install --user awscli
+
+    # Add ~/.local/bin to PATH if not already there (where pip --user installs)
+    if [[ ":$PATH:" != *":$HOME/.local/bin:"* ]]; then
+        export PATH="$HOME/.local/bin:$PATH"
+        echo "Added ~/.local/bin to PATH"
+    fi
+
+    # Verify installation
+    if command -v aws &> /dev/null; then
+        echo "AWS CLI v1 installed successfully:"
+        aws --version
+    else
+        echo "Error: AWS CLI v1 installation failed or not found in PATH" >&2
+        return 1
+    fi
+}
+
+# Main installation logic
+install_aws_cli() {
+    local arch
+    arch=$(detect_architecture)
+
+    case "${arch}" in
+        ppc64le|s390x)
+            echo "IBM architecture detected (${arch}). Using pip installation..."
+            install_aws_cli_pip
+            ;;
+        x86_64|aarch64|arm64)
+            echo "Standard architecture detected (${arch}). Using binary installation..."
+            install_aws_cli_binary "${arch}"
+            ;;
+        *)
+            echo "Warning: Unknown architecture ${arch}. Falling back to pip installation..."
+            install_aws_cli_pip
+            ;;
+    esac
+}
+
+install_aws_cli
 
 docker_dir="/home/${USER}/.docker"
 if [[ ! -d "${docker_dir}" ]]; then
@@ -21,7 +121,5 @@ fi
 
 sudo chown "${USER}":"${USER}" "${docker_dir}" -R
 sudo chmod g+rwx "${docker_dir}" -R
-sudo ./aws/install --bin-dir "${BIN_LOCATION}" --install-dir "${INSTALL_DIR}" --update
-cd -
 
-rm -rf "${tmpdir}"
+echo "AWS CLI setup completed successfully."
diff --git a/scripts/evergreen/setup_jq.sh b/scripts/evergreen/setup_jq.sh
index e21d4a07e..ed09a4dfe 100755
--- a/scripts/evergreen/setup_jq.sh
+++ b/scripts/evergreen/setup_jq.sh
@@ -7,7 +7,34 @@
 
 set -Eeou pipefail
 
-source scripts/dev/set_env_context.sh
 source scripts/funcs/install
 
-download_and_install_binary "${PROJECT_DIR:-.}/bin" jq "https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64"
+# Detect and map architecture for jq releases
+detect_jq_architecture() {
+    local arch
+    arch=$(uname -m)
+
+    case "${arch}" in
+        x86_64)
+            echo "amd64"
+            ;;
+        aarch64|arm64)
+            echo "arm64"
+            ;;
+        ppc64le)
+            echo "ppc64el"  # jq uses ppc64el instead of ppc64le
+            ;;
+        s390x)
+            echo "s390x"
+            ;;
+        *)
+            echo "Error: Unsupported architecture for jq: ${arch}" >&2
+            exit 1
+            ;;
+    esac
+}
+
+jq_arch=$(detect_jq_architecture)
+echo "Detected architecture: $(uname -m), using jq architecture: ${jq_arch}"
+
+download_and_install_binary "${PROJECT_DIR:-${workdir}}/bin" jq "https://github.com/stedolan/jq/releases/download/jq-1.8.1/jq-linux-${jq_arch}"
diff --git a/scripts/evergreen/setup_kind.sh b/scripts/evergreen/setup_kind.sh
index 96b315a78..b8a907404 100755
--- a/scripts/evergreen/setup_kind.sh
+++ b/scripts/evergreen/setup_kind.sh
@@ -5,12 +5,19 @@ source scripts/dev/set_env_context.sh
 
 # Store the lowercase name of Operating System
 os=$(uname | tr '[:upper:]' '[:lower:]')
+# Detect architecture
+arch=$(uname -m)
+case ${arch} in
+    x86_64) arch_suffix="amd64" ;;
+    aarch64|arm64) arch_suffix="arm64" ;;
+    *) echo "Unsupported architecture: ${arch}" >&2; exit 1 ;;
+esac
 # This should be changed when needed
 latest_version="v0.27.0"
 
 mkdir -p "${PROJECT_DIR}/bin/"
 echo "Saving kind to ${PROJECT_DIR}/bin"
-curl --retry 3 --silent -L "https://github.com/kubernetes-sigs/kind/releases/download/${latest_version}/kind-${os}-amd64" -o kind
+curl --retry 3 --silent -L "https://github.com/kubernetes-sigs/kind/releases/download/${latest_version}/kind-${os}-${arch_suffix}" -o kind
 
 chmod +x kind
 sudo mv kind "${PROJECT_DIR}/bin"
diff --git a/scripts/evergreen/setup_kubectl.sh b/scripts/evergreen/setup_kubectl.sh
index ab9066ac1..00cf975fd 100755
--- a/scripts/evergreen/setup_kubectl.sh
+++ b/scripts/evergreen/setup_kubectl.sh
@@ -3,22 +3,52 @@ set -Eeou pipefail
 
 source scripts/dev/set_env_context.sh
 
+# Detect system architecture and map to kubectl/helm architecture names
+detect_architecture() {
+    local arch
+    arch=$(uname -m)
+    
+    case "${arch}" in
+        x86_64)
+            echo "amd64"
+            ;;
+        aarch64|arm64)
+            echo "arm64"
+            ;;
+        ppc64le)
+            echo "ppc64le"
+            ;;
+        s390x)
+            echo "s390x"
+            ;;
+        *)
+            echo "Unsupported architecture: ${arch}" >&2
+            echo "Supported architectures: x86_64 (amd64), aarch64 (arm64), ppc64le, s390x" >&2
+            exit 1
+            ;;
+    esac
+}
+
+# Detect the current architecture
+ARCH=$(detect_architecture)
+echo "Detected architecture: ${ARCH}"
+
 bindir="${PROJECT_DIR}/bin"
 tmpdir="${PROJECT_DIR}/tmp"
 mkdir -p "${bindir}" "${tmpdir}"
 
-echo "Downloading latest kubectl"
-curl -s --retry 3 -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
+echo "Downloading latest kubectl for ${ARCH}"
+curl -s --retry 3 -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/${ARCH}/kubectl"
 chmod +x kubectl
 echo "kubectl version --client"
 ./kubectl version --client
 mv kubectl "${bindir}"
 
-echo "Downloading helm"
+echo "Downloading helm for ${ARCH}"
 helm_archive="${tmpdir}/helm.tgz"
 helm_version="v3.17.1"
-curl -s https://get.helm.sh/helm-${helm_version}-linux-amd64.tar.gz --output "${helm_archive}"
+curl -s https://get.helm.sh/helm-${helm_version}-linux-${ARCH}.tar.gz --output "${helm_archive}"
 
 tar xfz "${helm_archive}" -C "${tmpdir}" &> /dev/null
-mv "${tmpdir}/linux-amd64/helm" "${bindir}"
+mv "${tmpdir}/linux-${ARCH}/helm" "${bindir}"
 "${bindir}"/helm version
diff --git a/scripts/evergreen/setup_kubernetes_environment.sh b/scripts/evergreen/setup_kubernetes_environment.sh
index 707231c9f..fb6e2ee00 100755
--- a/scripts/evergreen/setup_kubernetes_environment.sh
+++ b/scripts/evergreen/setup_kubernetes_environment.sh
@@ -7,7 +7,7 @@ source scripts/funcs/kubernetes
 # shellcheck disable=SC2154
 bindir="${PROJECT_DIR}/bin"
 
-if [[ "${KUBE_ENVIRONMENT_NAME}" == "vanilla" || ("${KUBE_ENVIRONMENT_NAME}" == "multi" && "${CLUSTER_TYPE}" == "kops") ]]; then
+if [[ "${KUBE_ENVIRONMENT_NAME}" == "vanilla" || ("${KUBE_ENVIRONMENT_NAME}" == "multi" && "${CLUSTER_TYPE}" == "minikube") ]]; then
     export AWS_ACCESS_KEY_ID="${mms_eng_test_aws_access_key:?}"
     export AWS_SECRET_ACCESS_KEY="${mms_eng_test_aws_secret:?}"
     export AWS_DEFAULT_REGION="${mms_eng_test_aws_region:?}"
@@ -30,6 +30,8 @@ elif [ "${KUBE_ENVIRONMENT_NAME}" = "kind" ] || [ "${KUBE_ENVIRONMENT_NAME}" = "
     scripts/dev/recreate_kind_cluster.sh "kind"
 elif [[ "${KUBE_ENVIRONMENT_NAME}" = "multi" && "${CLUSTER_TYPE}" == "kind" ]]; then
     scripts/dev/recreate_kind_clusters.sh
+elif [[ "${KUBE_ENVIRONMENT_NAME}" = "minikube" ]]; then
+    echo "Nothing to do for minikube"
 else
     echo "KUBE_ENVIRONMENT_NAME not recognized"
     echo "value is <<${KUBE_ENVIRONMENT_NAME}>>. If empty it means it was not set"
diff --git a/scripts/evergreen/setup_minikube_host.sh b/scripts/evergreen/setup_minikube_host.sh
new file mode 100755
index 000000000..5424ecfb4
--- /dev/null
+++ b/scripts/evergreen/setup_minikube_host.sh
@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+
+# Consolidated setup script for minikube host with multi-architecture support
+# This script groups all the setup steps needed for IBM machines and other architectures
+# Can be run on static hosts for testing and verification
+
+source scripts/dev/set_env_context.sh
+set -Eeoux pipefail
+
+echo "=========================================="
+echo "Setting up minikube host with multi-architecture support"
+echo "Architecture: $(uname -m)"
+echo "OS: $(uname -s)"
+echo "=========================================="
+
+# Function to run a setup step with error handling and logging
+run_setup_step() {
+    local step_name="$1"
+    shift
+    local script_command=("$@")
+
+    echo ""
+    echo ">>> Running: ${step_name}"
+    echo ">>> Command: ${script_command[*]}"
+
+    local script_path="${script_command[0]}"
+    if [[ -f "${script_path}" ]]; then
+        if "${script_command[@]}"; then
+            echo "✅ ${step_name} completed successfully"
+        else
+            echo "❌ ${step_name} failed"
+            exit 1
+        fi
+    else
+        echo "❌ Script not found: ${script_path}"
+        exit 1
+    fi
+}
+
+# Setup Python environment (needed for AWS CLI pip installation)
+export GRPC_PYTHON_BUILD_SYSTEM_OPENSSL=1
+export SKIP_INSTALL_REQUIREMENTS=true
+run_setup_step "Python Virtual Environment" "scripts/dev/recreate_python_venv.sh"
+
+run_setup_step "AWS CLI Setup" "scripts/evergreen/setup_aws.sh"
+
+run_setup_step "kubectl and helm Setup" "scripts/evergreen/setup_kubectl.sh"
+
+run_setup_step "jq Setup" "scripts/evergreen/setup_jq.sh"
+
+run_setup_step "Minikube Host Setup with Container Runtime Detection" "scripts/minikube/setup_minikube_host.sh"
+
+export CONTAINER_RUNTIME=podman
+run_setup_step "Container Registry Authentication" "scripts/dev/configure_docker_auth.sh"
+
+# The minikube cluster is already started by the setup_minikube_host.sh script
+echo ""
+echo ">>> Minikube cluster startup completed by setup_minikube_host.sh"
+echo "✅ Minikube cluster is ready for use"
+
+echo ""
+echo "=========================================="
+echo "✅ Minikube host setup completed successfully!"
+echo "=========================================="
+echo ""
+echo "Installed tools summary:"
+echo "- Python: $(python --version 2>/dev/null || python3 --version 2>/dev/null || echo 'Not found')"
+echo "- AWS CLI: $(aws --version 2>/dev/null || echo 'Not found')"
+echo "- kubectl: $(kubectl version --client 2>/dev/null || echo 'Not found')"
+echo "- helm: $(helm version --short 2>/dev/null || echo 'Not found')"
+echo "- jq: $(jq --version 2>/dev/null || echo 'Not found')"
+echo "- Container Runtime: $(command -v podman &>/dev/null && echo "Podman $(podman --version 2>/dev/null)" || command -v docker &>/dev/null && echo "Docker $(docker --version 2>/dev/null)" || echo "Not found")"
+echo "- Minikube: $(./bin/minikube version --short 2>/dev/null || echo 'Not found')"
+echo ""
+echo "Setup complete! Host is ready for minikube operations."
diff --git a/scripts/evergreen/teardown_kubernetes_environment.sh b/scripts/evergreen/teardown_kubernetes_environment.sh
index e5e2bd869..a9babfbed 100755
--- a/scripts/evergreen/teardown_kubernetes_environment.sh
+++ b/scripts/evergreen/teardown_kubernetes_environment.sh
@@ -5,6 +5,12 @@ set -Eeou pipefail
 source scripts/dev/set_env_context.sh
 
 if [ "${KUBE_ENVIRONMENT_NAME}" = "kind" ]; then
+    docker system prune -a -f
     echo "Deleting Kind cluster"
     kind delete clusters --all
 fi
+
+if [ "${KUBE_ENVIRONMENT_NAME}" = "minikube" ]; then
+    echo "Deleting minikube cluster"
+    "${PROJECT_DIR:-.}/bin/minikube" delete
+fi
diff --git a/scripts/funcs/kubernetes b/scripts/funcs/kubernetes
index 5377d8927..11250422d 100644
--- a/scripts/funcs/kubernetes
+++ b/scripts/funcs/kubernetes
@@ -98,15 +98,40 @@ create_image_registries_secret() {
     context=$1
     namespace=$2
     secret_name=$3
+    
+    # Detect the correct config file path based on container runtime
+    local config_file
+    local temp_config_file=""
+    if command -v podman &> /dev/null && (podman info &> /dev/null || sudo podman info &> /dev/null); then
+      # For Podman, use root's auth.json since minikube uses sudo podman
+      config_file="/root/.config/containers/auth.json"
+      echo "Using Podman config: ${config_file}"
+      
+      # Create a temporary copy that the current user can read
+      temp_config_file=$(mktemp)
+      sudo cp "${config_file}" "${temp_config_file}"
+      sudo chown "$(whoami):$(whoami)" "${temp_config_file}"
+      config_file="${temp_config_file}"
+    else
+      # For Docker, use standard docker config
+      config_file="${HOME}/.docker/config.json"
+      echo "Using Docker config: ${config_file}"
+    fi
+    
     # shellcheck disable=SC2154
     if kubectl --context "${context}" get namespace "${namespace}"; then
       kubectl --context "${context}" -n "${namespace}" delete secret "${secret_name}" --ignore-not-found
       echo "${context}: Creating ${namespace}/${secret_name} pull secret"
       kubectl --context "${context}" -n "${namespace}" create secret generic "${secret_name}" \
-        --from-file=.dockerconfigjson="${HOME}/.docker/config.json" --type=kubernetes.io/dockerconfigjson
+        --from-file=.dockerconfigjson="${config_file}" --type=kubernetes.io/dockerconfigjson
     else
       echo "Skipping creating pull secret in ${context}/${namespace}. The namespace doesn't exist yet."
     fi
+    
+    # Clean up temporary file
+    if [[ -n "${temp_config_file}" ]] && [[ -f "${temp_config_file}" ]]; then
+      rm -f "${temp_config_file}"
+    fi
   }
 
   echo "Creating/updating pull secret from docker configured file"
diff --git a/scripts/minikube/install-minikube.sh b/scripts/minikube/install-minikube.sh
new file mode 100755
index 000000000..527b27543
--- /dev/null
+++ b/scripts/minikube/install-minikube.sh
@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+set -Eeou pipefail
+
+source scripts/dev/set_env_context.sh
+source scripts/funcs/install
+
+# Detect architecture
+ARCH=$(uname -m)
+case "${ARCH}" in
+    x86_64)
+        MINIKUBE_ARCH="amd64"
+        ;;
+    aarch64)
+        MINIKUBE_ARCH="arm64"
+        ;;
+    ppc64le)
+        MINIKUBE_ARCH="ppc64le"
+        ;;
+    s390x)
+        MINIKUBE_ARCH="s390x"
+        ;;
+    *)
+        echo "Error: Unsupported architecture: ${ARCH}"
+        echo "Supported architectures: x86_64, aarch64, ppc64le, s390x"
+        exit 1
+        ;;
+esac
+
+echo "Installing minikube on ${ARCH} architecture..."
+
+# Install crictl (container runtime CLI)
+echo "Installing crictl for ${ARCH}..."
+CRICTL_VERSION=$(curl -s https://api.github.com/repos/kubernetes-sigs/cri-tools/releases/latest | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
+
+# Download and extract crictl tar.gz
+mkdir -p "${PROJECT_DIR:-.}/bin"
+CRICTL_URL="https://github.com/kubernetes-sigs/cri-tools/releases/download/${CRICTL_VERSION}/crictl-${CRICTL_VERSION}-linux-${MINIKUBE_ARCH}.tar.gz"
+echo "Downloading ${CRICTL_URL}"
+TEMP_DIR=$(mktemp -d)
+curl --retry 3 --silent -L "${CRICTL_URL}" -o "${TEMP_DIR}/crictl.tar.gz"
+tar -xzf "${TEMP_DIR}/crictl.tar.gz" -C "${TEMP_DIR}/"
+chmod +x "${TEMP_DIR}/crictl"
+mv "${TEMP_DIR}/crictl" "${PROJECT_DIR:-.}/bin/crictl"
+rm -rf "${TEMP_DIR}"
+echo "Installed crictl to ${PROJECT_DIR:-.}/bin"
+
+# Also install crictl system-wide so minikube can find it
+echo "Installing crictl system-wide..."
+if [[ -f "${PROJECT_DIR:-.}/bin/crictl" ]]; then
+    # Install to both /usr/local/bin and /usr/bin for better PATH coverage
+    sudo cp "${PROJECT_DIR:-.}/bin/crictl" /usr/local/bin/crictl
+    sudo cp "${PROJECT_DIR:-.}/bin/crictl" /usr/bin/crictl
+    sudo chmod +x /usr/local/bin/crictl
+    sudo chmod +x /usr/bin/crictl
+    echo "✅ crictl installed to /usr/local/bin/ and /usr/bin/"
+    
+    # Verify installation
+    if command -v crictl >/dev/null 2>&1; then
+        echo "✅ crictl is now available in PATH: $(which crictl)"
+        echo "✅ crictl version: $(crictl --version 2>/dev/null || echo 'version check failed')"
+    else
+        echo "⚠️  crictl installed but not found in PATH"
+    fi
+else
+    echo "⚠️  crictl not found in project bin, minikube may have issues"
+fi
+
+# Install minikube
+echo "Installing minikube for ${ARCH}..."
+MINIKUBE_VERSION=$(curl -s https://api.github.com/repos/kubernetes/minikube/releases/latest | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
+
+# Download minikube for detected architecture
+download_and_install_binary "${PROJECT_DIR:-.}/bin" minikube "https://github.com/kubernetes/minikube/releases/download/${MINIKUBE_VERSION}/minikube-linux-${MINIKUBE_ARCH}"
+
+echo "Crictl ${CRICTL_VERSION} and Minikube ${MINIKUBE_VERSION} installed successfully for ${ARCH}"
diff --git a/scripts/minikube/minikube_host.sh b/scripts/minikube/minikube_host.sh
new file mode 100755
index 000000000..09c5b80f7
--- /dev/null
+++ b/scripts/minikube/minikube_host.sh
@@ -0,0 +1,212 @@
+#!/usr/bin/env bash
+
+# This is a helper script for running tests on s390x Hosts.
+# It allows to configure minikube clusters and expose remote API servers on a local machine to
+# enable local development while running minikube cluster on s390x instance.
+# Run "minikube_host.sh help" command to see the full usage.
+# Similar to evg_host.sh but uses minikube instead of kind.
+
+set -Eeou pipefail
+
+test "${MDB_BASH_DEBUG:-0}" -eq 1 && set -x
+
+source scripts/dev/set_env_context.sh
+source scripts/funcs/printing
+
+if [[ -z "${S390_HOST_NAME}" ]]; then
+  echo "S390_HOST_NAME env var is missing"
+  echo "Set it to your s390x host connection string (e.g., user@hostname)"
+  exit 1
+fi
+
+get_host_url() {
+  echo "${S390_HOST_NAME}"
+}
+
+cmd=${1-""}
+
+if [[ "${cmd}" != "" && "${cmd}" != "help" ]]; then
+  host_url=$(get_host_url)
+fi
+
+kubeconfig_path="${HOME}/.operator-dev/s390-host.kubeconfig"
+
+configure() {
+  ssh -T -q "${host_url}" "sudo chown \$(whoami):\$(whoami) ~/.docker || true; mkdir -p ~/.docker"
+  if [[ -f "${HOME}/.docker/config.json" ]]; then
+    echo "Copying local ~/.docker/config.json authorization credentials to s390x host"
+    jq '. | with_entries(select(.key == "auths"))' "${HOME}/.docker/config.json" | ssh -T -q "${host_url}" 'cat > ~/.docker/config.json'
+  fi
+
+  sync
+
+  ssh -T -q "${host_url}" "cd ~/mongodb-kubernetes; scripts/dev/switch_context.sh root-context; scripts/minikube/setup_minikube_host.sh "
+}
+
+sync() {
+  rsync --verbose --archive --compress --human-readable --recursive --progress \
+  --delete --delete-excluded --max-size=1000000 --prune-empty-dirs \
+  -e ssh \
+  --include-from=.rsyncinclude \
+  --exclude-from=.gitignore \
+  --exclude-from=.rsyncignore \
+  ./ "${host_url}:~/mongodb-kubernetes/"
+
+  rsync --verbose --no-links --recursive --prune-empty-dirs --archive --compress --human-readable \
+    --max-size=1000000 \
+    -e ssh \
+    ~/.operator-dev/ \
+    "${host_url}:~/.operator-dev" &
+
+  wait
+}
+
+remote-prepare-local-e2e-run() {
+  set -x
+  sync
+  cmd make switch context=e2e_mdb_kind_ubi_cloudqa
+  cmd scripts/dev/prepare_local_e2e_run.sh
+  rsync --verbose --no-links --recursive --prune-empty-dirs --archive --compress --human-readable \
+    --max-size=1000000 \
+    -e ssh \
+    "${host_url}:~/mongodb-kubernetes/.multi_cluster_local_test_files" \
+    ./ &
+  scp "${host_url}:~/.operator-dev/multicluster_kubeconfig" "${KUBE_CONFIG_PATH}" &
+
+  wait
+}
+
+get-kubeconfig() {
+  # For minikube, we need to get the kubeconfig and certificates
+  echo "Getting kubeconfig from minikube on s390x host..."
+
+  # Create local minikube directory structure
+  mkdir -p "${HOME}/.minikube"
+
+  # Copy certificates from remote host
+  echo "Copying minikube certificates..."
+  scp "${host_url}:~/.minikube/ca.crt" "${HOME}/.minikube/"
+  scp "${host_url}:~/.minikube/client.crt" "${HOME}/.minikube/"
+  scp "${host_url}:~/.minikube/client.key" "${HOME}/.minikube/"
+
+  # Get kubeconfig and update paths to local ones
+  ssh -T -q "${host_url}" "cd ~/mongodb-kubernetes; export KUBE_ENVIRONMENT_NAME=minikube; kubectl config view --raw" > "${kubeconfig_path}"
+
+  # Update certificate paths to local paths
+  sed -i '' "s|/home/cloud-user/.minikube|${HOME}/.minikube|g" "${kubeconfig_path}"
+
+  # Update server addresses to use localhost for tunneling
+  sed -i '' "s|https://192.168.[0-9]*.[0-9]*:\([0-9]*\)|https://127.0.0.1:\1|g" "${kubeconfig_path}"
+
+  echo "Copied minikube kubeconfig and certificates to ${kubeconfig_path}"
+}
+
+recreate-minikube-cluster() {
+  configure "$(uname -m)" 2>&1| prepend "minikube_host.sh configure"
+  echo "Recreating minikube cluster on ${S390_HOST_NAME} (${host_url})..."
+  # shellcheck disable=SC2088
+  ssh -T "${host_url}" "cd ~/mongodb-kubernetes; export KUBE_ENVIRONMENT_NAME=minikube; minikube delete || true; minikube start --driver=podman --memory=8192mb --cpus=4"
+  echo "Copying kubeconfig to ${kubeconfig_path}"
+  get-kubeconfig
+}
+
+tunnel() {
+  shift 1
+  echo "Setting up tunnel for minikube cluster..."
+
+  # Get the minikube API server port from remote host
+  local api_port
+  api_port=$(ssh -T -q "${host_url}" "cd ~/mongodb-kubernetes; minikube ip 2>/dev/null && echo ':8443' | tr -d '\n'")
+
+  if [[ -z "${api_port}" ]]; then
+    echo "Could not determine minikube API server details. Is the cluster running?"
+    return 1
+  fi
+
+  # Extract just the port (8443)
+  local port="8443"
+  echo "Forwarding localhost:${port} to minikube cluster API server"
+
+  # Forward the API server port through minikube
+  set -x
+  # shellcheck disable=SC2029
+  ssh -L "${port}:$(ssh -T -q "${host_url}" "minikube ip"):${port}" "${host_url}" "$@"
+  set +x
+}
+
+retry_with_sleep() {
+  shift 1
+  cmd=$1
+  local sleep_time
+  sleep_time=5
+
+  while true; do
+    ${cmd} || true
+    echo "Retrying command after ${sleep_time} of sleep: ${cmd}"
+    sleep 5;
+  done
+}
+
+ssh_to_host() {
+  shift 1
+  # shellcheck disable=SC2029
+  ssh "$@" "${host_url}"
+}
+
+upload-my-ssh-private-key() {
+    ssh -T -q "${host_url}" "mkdir -p ~/.ssh"
+    scp "${HOME}/.ssh/id_rsa" "${host_url}:~/.ssh/id_rsa"
+    scp "${HOME}/.ssh/id_rsa.pub" "${host_url}:~/.ssh/id_rsa.pub"
+    ssh -T -q "${host_url}" "chmod 700 ~/.ssh && chown -R \$(whoami):\$(whoami) ~/.ssh"
+}
+
+cmd() {
+  if [[ "$1" == "cmd" ]]; then
+    shift 1
+  fi
+
+  cmd="cd ~/mongodb-kubernetes; $*"
+  ssh -T -q "${host_url}" "${cmd}"
+}
+
+usage() {
+  echo "USAGE:
+  minikube_host.sh <command>
+
+PREREQUISITES:
+  - s390x host with SSH access
+  - define S390_HOST_NAME env var (e.g., export S390_HOST_NAME=user@hostname)
+  - SSH key-based authentication configured
+
+COMMANDS:
+  configure <architecture>           installs on a host: calls sync, switches context, installs necessary software (auto-detects arch)
+  sync                              rsync of project directory
+  recreate-minikube-cluster          recreates minikube cluster and executes get-kubeconfig
+  remote-prepare-local-e2e-run       executes prepare-local-e2e on the remote host
+  get-kubeconfig                     copies remote minikube kubeconfig locally to ~/.operator-dev/s390-host.kubeconfig
+  tunnel [args]                      creates ssh session with tunneling to all API servers
+  ssh [args]                         creates ssh session passing optional arguments to ssh
+  cmd [command with args]            execute command as if being on s390x host
+  upload-my-ssh-private-key          uploads your ssh keys (~/.ssh/id_rsa) to s390x host
+  help                               this message
+
+EXAMPLES:
+  export S390_HOST_NAME=user@ibmz8
+  minikube_host.sh tunnel
+  minikube_host.sh cmd 'make e2e test=replica_set'
+"
+}
+
+case ${cmd} in
+configure) configure "$@" ;;
+recreate-minikube-cluster) recreate-minikube-cluster "$@" ;;
+get-kubeconfig) get-kubeconfig ;;
+remote-prepare-local-e2e-run) remote-prepare-local-e2e-run ;;
+ssh) ssh_to_host "$@" ;;
+tunnel) retry_with_sleep tunnel "$@" ;;
+sync) sync ;;
+cmd) cmd "$@" ;;
+upload-my-ssh-private-key) upload-my-ssh-private-key ;;
+help) usage ;;
+*) usage ;;
+esac
diff --git a/scripts/minikube/setup_minikube_host.sh b/scripts/minikube/setup_minikube_host.sh
new file mode 100755
index 000000000..16f1c1c31
--- /dev/null
+++ b/scripts/minikube/setup_minikube_host.sh
@@ -0,0 +1,255 @@
+#!/usr/bin/env bash
+
+# this script downloads necessary tooling for alternative architectures (s390x, ppc64le) using minikube (similar to setup_evg_host.sh)
+source scripts/dev/set_env_context.sh
+
+set -Eeou pipefail
+
+set_limits() {
+  echo "Increasing fs.inotify.max_user_instances"
+  sudo sysctl -w fs.inotify.max_user_instances=8192
+
+  echo "Increasing fs.inotify.max_user_watches"
+  sudo sysctl -w fs.inotify.max_user_watches=10485760
+
+  echo "Increasing the number of open files"
+  nofile_max=$(cat /proc/sys/fs/nr_open)
+  nproc_max=$(ulimit -u)
+  sudo tee -a /etc/security/limits.conf <<EOF
+  root hard nofile ${nofile_max}
+  root hard nproc ${nproc_max}
+  root soft nofile ${nofile_max}
+  root soft nproc ${nproc_max}
+  * hard nofile ${nofile_max}
+  * hard nproc ${nproc_max}
+  * soft nofile ${nofile_max}
+  * soft nproc ${nproc_max}
+EOF
+}
+
+# retrieve arch variable off the shell command line
+ARCH=${1-"$(uname -m)"}
+
+echo "Setting up minikube host for architecture: ${ARCH}"
+
+download_minikube() {
+  echo "Downloading minikube for ${ARCH}..."
+  scripts/minikube/install-minikube.sh
+}
+
+# Setup local registry and build custom kicbase image for ppc64le with crictl
+setup_local_registry_and_custom_image() {
+  if [[ "${ARCH}" == "ppc64le" ]]; then
+    echo ">>> Setting up local registry and custom kicbase image for ppc64le..."
+
+    # Check if local registry is running (with fallback for namespace issues)
+    registry_running=false
+    if curl -s http://localhost:5000/v2/_catalog >/dev/null 2>&1; then
+      echo "Registry detected via HTTP check (podman ps failed)"
+      registry_running=true
+    fi
+
+    if ! $registry_running; then
+      echo "Starting local container registry on port 5000..."
+
+      # Clean up any existing registry first
+      sudo podman rm -f registry 2>/dev/null || true
+
+      if ! sudo podman run -d -p 5000:5000 --name registry --restart=always docker.io/library/registry:2; then
+        echo "❌ Failed to start local registry - trying alternative approach"
+        exit 1
+      fi
+
+      # Wait for registry to be ready
+      echo "Waiting for registry to be ready..."
+      for i in {1..30}; do
+        if curl -s http://localhost:5000/v2/_catalog >/dev/null 2>&1; then
+          break
+        fi
+        sleep 1
+      done
+    else
+      echo "✅ Local registry already running"
+    fi
+
+    # Configure podman to trust local registry (both user and root level for minikube)
+    echo "Configuring registries.conf to trust local registry..."
+
+    # User-level config
+    mkdir -p ~/.config/containers
+    cat > ~/.config/containers/registries.conf << 'EOF'
+[[registry]]
+location = "localhost:5000"
+insecure = true
+EOF
+
+    # Root-level config (since minikube uses sudo podman)
+    sudo mkdir -p /root/.config/containers
+    sudo tee /root/.config/containers/registries.conf << 'EOF' >/dev/null
+[[registry]]
+location = "localhost:5000"
+insecure = true
+EOF
+
+    echo "✅ Registry configuration created for both user and root"
+    custom_image_tag="localhost:5000/kicbase:v0.0.47"
+
+    # Determine image tag
+    custom_image_tag="localhost:5000/kicbase:v0.0.47"
+    if curl -s http://localhost:5000/v2/kicbase/tags/list | grep -q "v0.0.47"; then
+      echo "Custom kicbase image already exists in local registry"
+      return 0
+    fi
+
+    # Build custom kicbase image with crictl
+    echo "Building custom kicbase image with crictl for ppc64le..."
+
+    # Build custom kicbase image
+    mkdir -p "${PROJECT_DIR:-.}/scripts/minikube/kicbase"
+    cat > "${PROJECT_DIR:-.}/scripts/minikube/kicbase/Dockerfile" << 'EOF'
+FROM gcr.io/k8s-minikube/kicbase:v0.0.47
+RUN if [ "$(uname -m)" = "ppc64le" ]; then \
+        CRICTL_VERSION="v1.28.0" && \
+        curl -L "https://github.com/kubernetes-sigs/cri-tools/releases/download/${CRICTL_VERSION}/crictl-${CRICTL_VERSION}-linux-ppc64le.tar.gz" \
+            -o /tmp/crictl.tar.gz && \
+        tar -C /usr/bin -xzf /tmp/crictl.tar.gz && \
+        chmod +x /usr/bin/crictl && \
+        rm /tmp/crictl.tar.gz; \
+    fi
+EOF
+
+    cd "${PROJECT_DIR:-.}/scripts/minikube/kicbase"
+    sudo podman build -t "${custom_image_tag}" . || {
+      echo "Failed to build custom image"
+      return 1
+    }
+    sudo podman push "${custom_image_tag}" --tls-verify=false || {
+      echo "Failed to push to registry"
+      return 1
+    }
+    cd - >/dev/null
+    echo "Custom kicbase image ready: ${custom_image_tag}"
+  fi
+  return 0
+}
+
+# Start minikube with podman driver
+start_minikube_cluster() {
+  echo ">>> Starting minikube cluster with podman driver..."
+
+  # Clean up any existing minikube state to avoid cached configuration issues
+  echo "Cleaning up any existing minikube state..."
+  if [[ -d ~/.minikube/machines/minikube ]]; then
+    echo "Removing ~/.minikube/machines/minikube directory..."
+    rm -rf ~/.minikube/machines/minikube
+  fi
+
+  echo "Ensuring clean minikube state..."
+  "${PROJECT_DIR:-.}/bin/minikube" delete 2>/dev/null || true
+
+  local start_args=("--driver=podman")
+
+  if [[ "${ARCH}" == "ppc64le" ]]; then
+    echo "Using custom kicbase image for ppc64le with crictl..."
+
+    start_args+=("--base-image=localhost:5000/kicbase:v0.0.47")
+    start_args+=("--insecure-registry=localhost:5000")
+  fi
+
+  # Use default bridge CNI to avoid Docker Hub rate limiting issues
+  # start_args+=("--cni=bridge")
+
+  echo "Starting minikube with args: ${start_args[*]}"
+  if "${PROJECT_DIR:-.}/bin/minikube" start "${start_args[@]}"; then
+    echo "✅ Minikube started successfully"
+  else
+    echo "❌ Minikube failed to start"
+    echo "Minikube logs:"
+    "${PROJECT_DIR:-.}/bin/minikube" logs | tail -20
+    return 1
+  fi
+}
+
+setup_podman() {
+  echo "Setting up podman for ${ARCH}..."
+
+  # Check if podman is already available
+  if command -v podman &> /dev/null; then
+    echo "✅ Podman already installed"
+
+    # Diagnose podman state
+    echo "=== Podman Diagnostics ==="
+    echo "User: $(whoami), UID: $(id -u)"
+    echo "User namespace support: $(cat /proc/self/uid_map 2>/dev/null || echo 'not available')"
+    echo "Systemctl user status:"
+    systemctl --user status podman.socket 2>/dev/null || echo "podman.socket not active"
+    echo "Running 'sudo podman info' command..."
+    sudo podman info 2>&1
+  fi
+
+
+  # Configure podman to use cgroupfs instead of systemd in CI
+  mkdir -p ~/.config/containers
+  cat > ~/.config/containers/containers.conf << EOF
+[containers]
+cgroup_manager = "cgroupfs"
+events_logger = "file"
+
+[engine]
+cgroup_manager = "cgroupfs"
+EOF
+
+}
+
+# Setup podman and container runtime
+setup_podman
+set_limits
+download_minikube
+
+# Setup local registry and custom kicbase image for ppc64le if needed
+setup_local_registry_and_custom_image
+
+echo ""
+echo ">>> Verifying minikube installation..."
+if command -v minikube &> /dev/null; then
+    minikube_version=$(minikube version --short 2>/dev/null || minikube version 2>/dev/null | head -n1)
+    echo "✅ Minikube installed successfully: ${minikube_version}"
+else
+    echo "❌ Minikube installation failed - minikube command not found"
+    echo "Please check the installation logs above for errors"
+    exit 1
+fi
+
+if [[ "${ARCH}" == "ppc64le" ]]; then
+    echo ""
+    echo ">>> Note: crictl will be patched into the minikube container after startup"
+else
+    echo ""
+    echo ">>> Using standard kicbase image (crictl included for x86_64/aarch64/s390x)"
+fi
+
+# Start the minikube cluster
+start_minikube_cluster
+
+# Update kubectl context to point to the running cluster
+echo ""
+echo ">>> Updating kubectl context for minikube cluster..."
+"${PROJECT_DIR:-.}/bin/minikube" update-context
+echo "✅ Kubectl context updated successfully"
+
+echo "Minikube host setup completed successfully for ${ARCH}!"
+
+# Final status
+echo ""
+echo "=========================================="
+echo "✅ Setup Summary"
+echo "=========================================="
+echo "Architecture: ${ARCH}"
+echo "Container Runtime: podman"
+echo "Minikube Driver: podman"
+echo "Minikube: Default cluster"
+echo "Minikube: ${minikube_version}"
+echo "CNI: bridge (default)"
+if [[ "${ARCH}" == "ppc64le" ]]; then
+    echo "Special Config: Custom kicbase image with crictl via local registry"
+fi
