CCOA (IJCAHPO) study plan

Map every objective in the Cloud Architecture and Design domain to a personal confidence score (1–5) and flag any score below 3 for extra review time.

Sketch three reference architectures (multi-tier web, event-driven serverless, and hybrid connectivity) on paper, labeling each component, trust boundary, and failure domain.

Compare at least four cloud design patterns (e.g., bulkhead, circuit breaker, queue-based load leveling, strangler fig) and write a one-paragraph trade-off summary for each.

Explain the shared responsibility model for IaaS, PaaS, and SaaS by writing a table that assigns 10 common controls to either provider or customer.

Design a highly available three-tier application that spans at least two availability zones, and document the RTO/RPO assumptions behind every data store choice.

Draft a migration plan (rehost, replatform, refactor, retire) for a legacy on-premises workload, assigning each tier a migration strategy and a target landing zone.

Define an orchestration workflow that automates a daily backup, validation, and restore-drill sequence, and identify the idempotency guarantees required at each step.

Build a decision table that selects between workflow orchestration, event-driven choreography, and scheduled batch for six given scenarios.

Implement a small orchestration workflow (three or more steps) using a workflow engine or scripting framework, including retry, timeout, and compensation logic.

Instrument the workflow with structured logs and a correlation ID, then prove end-to-end traceability by following one request through every step.

Write runbooks for the two most likely failure modes of the workflow (step timeout and partial failure) and test each runbook by injecting the fault.

Compare at least three orchestration approaches (managed workflow service, Kubernetes-native jobs, event bus with consumers) and record selection criteria in a scorecard.

Write infrastructure as code that provisions a network, compute instance, and storage bucket from scratch, using variables, outputs, and a remote state backend.

Refactor the code into at least two reusable modules (network and compute) and document each module's inputs, outputs, and versioning policy.

Add a configuration-management layer (e.g., Ansible playbook or cloud-init) that installs and configures a web server on the provisioned instance.

Run a plan/apply cycle, deliberately introduce drift by changing a resource manually, then detect and correct the drift using the tooling.

Containerize a sample application with a multi-stage Dockerfile, reducing the final image size by at least 50 percent compared with a naive build.

Deploy the containerized application to a local Kubernetes cluster using a Deployment and a Service, and verify rollout and rollback behavior.

Externalize configuration with ConfigMaps and Secrets, and demonstrate a rolling update triggered only by a ConfigMap change.

Apply an IaC module to provision the Kubernetes namespace and RBAC bindings, keeping cluster configuration in version control.

Build a CI pipeline that lints, tests, builds the container image, scans it for vulnerabilities, and pushes it to a registry on every commit.

Add a CD stage that deploys to the Kubernetes cluster using a canary or blue-green strategy, with automated promotion gated on health checks.

Implement semantic versioning and automated changelog generation, then tag and release the application through the pipeline.

Write a rollback procedure and prove it by deploying a deliberately broken release and reverting to the previous version within the pipeline.

Instrument the application with the three pillars: metrics (request rate, error rate, duration), structured logs, and at least one distributed trace.

Create dashboards and two alerts (error-rate burn and latency SLO breach) that fire in a test environment, and record the alert payloads.

Harden the deployment by enforcing least-privilege IAM, enabling encryption at rest and in transit, and adding a policy-as-code check that blocks noncompliant resources.

Map five compliance controls (e.g., audit logging, access review, data retention) to concrete configuration settings and verify each with a scripted check.

Right-size the compute and storage from earlier weeks using utilization data, and quantify the monthly cost delta in a before-and-after table.

Identify three performance bottlenecks in the deployed application, apply one optimization, and measure the improvement with before-and-after latency numbers.

Re-run the domain-1 confidence matrix and build a 20-question mixed practice set weighted to the two lowest-scoring domains, then score at least 80 percent.

Produce a one-page exam-day plan that lists the top five weak objectives, the review resource for each, and the time budget per domain during the exam.