Extended cluster deployment and IAM configuration for the billing workload, including service identity and Pub/Sub access. No cluster deployment occurred, so configuration correctness and runtime reliability were not observed.
What worked
The existing deployment pattern provided a clear place to add the service, environment variables, and workload permissions.
What got in the way
IAM role separation and hosted deployment behavior required manual review because no plan or cluster execution was available.
Got in the wayConfigurationPermissionsExtra context
Extended cluster config with a billing namespace and workload identity in the same style as the other services, keeping it off the card-data namespace. Nothing was applied to a cluster.
What worked
Existing namespace and identity bindings were a sufficient template for a service that must stay outside the card-data environment.
Extended cluster configuration so the new service gets its own namespace and identity instead of landing in the cardholder namespace. No cluster apply was run.
What worked
The existing Autopilot module showed where to put a non-cardholder namespace and service account without touching the payments cluster boundary.
What got in the way
Network policy, identity binding, and scheduling were never validated on a live cluster.
Added a billing namespace and workload identity wiring next to the existing non-processing services so the new workload could run on the cluster without entering the cardholder environment. Nothing was deployed.
What worked
Cluster comments, namespace, and identity bindings for other out-of-scope services were easy to extend for billing.
What got in the way
Network policy and identity changes were documentation-and-config only; cluster admission and runtime identity were not observed.
Extended cluster configuration for the new billing workload and its service identity. The files were incorporated into the implementation, but no infrastructure plan or deployment was run.
What worked
The existing cluster configuration provided a clear place to add the isolated workload identity.
What got in the way
The configuration could not be validated against the provider or a live cluster because the infrastructure executable was unavailable.
Extended cluster workload and identity config so billing can run outside the cardholder environment next to existing services. Nothing was applied to a live cluster.
What worked
Workload identity and per-service publisher bindings were already modeled, which made a PCI-separated billing workload a natural addition.
What got in the way
The first service-loop update did not cover every resource that still listed only the original workloads, so a second pass was required. Deploy was not verified.
Extended cluster config with a billing namespace and identity so the new service can run outside the card-environment namespace. Nothing was deployed to a cluster.
What worked
Namespace and workload identity patterns in the existing config were enough to place billing beside ledger and webhooks rather than in the payments namespace.
Extended the existing infrastructure configuration to deploy the billing service and connect it to its database and messaging resources. The deployment definition was not planned or applied against a cluster.
What worked
The existing service deployment pattern could be extended for billing without introducing a separate orchestration approach.
Extended cluster workload identity and service wiring so the new billing workload can reach Pub/Sub and its database the same way the other services already do.
What worked
Publisher and identity blocks were consistent enough to add one more service without a new access model.
What got in the way
Nothing was applied to a cluster, so identity binding and pod startup were not verified.
Extended cluster service loops and workload identity bindings so the new billing workload can run beside existing services with its own database client. No cluster apply or deploy was performed.
What worked
For-each style service wiring meant billing could be added as another named service rather than a one-off deployment, including identity for cloud APIs.
What got in the way
Comment and loop edits had to be re-read to ensure the new service was included everywhere ledger and payments already were. Nothing validated the rendered manifests.
Extended cluster infrastructure config so the new service could run with the same workload identity pattern as the others. The cluster was not updated, and namespace identity for billing could not be fully added in this pass.
What worked
Existing workload comments and identity bindings showed where a new service belongs on the cluster.
What got in the way
Billing namespace identity could not be completed here, and no cluster apply ran, so scheduling and identity were unverified.
Added workload identity and service wiring so the new rating service can deploy beside the existing independently deployed services. Nothing was applied to a cluster.
What worked
Following the current workload pattern was enough to place another service on the cluster with the same identity model.
Extended the cluster infrastructure configuration with billing service account and Workload Identity wiring. The intended deployment permissions were represented, but no plan, deployment, or live cluster behavior was available to verify them.
What worked
Workload Identity provided a clear model for avoiding static cloud credentials in the service.
What got in the way
Infrastructure validation could not run because the required CLI was absent.
Got in the wayMissing toolConfigurationPermissions
Extended the Autopilot service layout so the new invoicing workload deploys beside the non-card services instead of inside the card-data cluster. The change was configuration only and was not applied to a cluster.
What worked
Existing namespace and workload patterns made it obvious where a new independently deployed service should live.
Added a dedicated namespace and related cluster config so the billing workload would not sit in the card-data namespace. This was infrastructure text following the existing cluster layout, not a live deploy, so isolation was designed rather than proven on the cluster.
What worked
Namespace and service-account style resources in the existing cluster config were enough to place billing beside the other non-card-data services.
What got in the way
No cluster apply or workload rollout happened, so network policy and namespace isolation were not observed.
Added cluster workload, service account, and identity bindings for the new billing process so it could run beside the other services and reach its database and event bus.
What worked
The existing workload definition was a clear template for another service, including identity for database and messaging access.
What got in the way
No cluster apply or rollout was run, so scheduling and identity binding were not observed live.
Extended deployment configuration for the new service and its cloud identity bindings. The changes were static only; no cluster deployment or identity verification occurred.
What worked
The existing deployment pattern could be extended to include another service and its database and messaging access.
What got in the way
Cluster behavior and workload identity permissions remained unverified without an infrastructure plan or live environment.
Got in the wayConfigurationPermissionsExtra context
Extended deployment configuration for the new billing workload and its service endpoints within the non-CDE cluster boundary. No deployment occurred, and workload and network policy changes in a separate infrastructure repository were still required.
What worked
The cluster placement provided a clear internal boundary between card-processing systems, billing, and external invoice export.
What got in the way
The record could not validate scheduling, networking, or health in a live cluster, and part of the deployment policy lived outside the available repository.
Extended infrastructure configuration so the billing workload could use a dedicated cloud service account. Configuration formatted and validated, but it was not applied to a live cluster.
What worked
Workload identity provided a clear way to separate permissions between payment, ledger, and billing workloads.
What got in the way
No deployment or in-cluster identity exchange was tested.
Declared a billing workload, namespace, and identity so the new service can deploy like the other independently shipped apps. This was config only; no cluster apply or rollout was run.
What worked
Existing workload modules showed how to add another service without placing it in the card-processing namespace.
What got in the way
No cluster plan or deploy was run, so scheduling, networking, and identity at runtime were not observed.
Wired a billing workload and SQL client identity by extending the existing Autopilot and Workload Identity config, including a mistaken display field rename that had to be reverted. Deploy was not applied, so cluster behavior was not observed.
What worked
Service account, Workload Identity, and SQL client grants were easy to clone for an additional microservice.
What got in the way
A display field was briefly renamed incorrectly while editing identity config and needed a follow-up fix.