ODC Architecture Specialist study plan

Draw a four-layer reference diagram (presentation, application service, integration, data) for a realistic order-management scenario and label every boundary and trust zone.

Classify at least ten quality attributes as architectural drivers or constraints, and record which attribute you would trade away for each one.

Write a two-sentence contrast of layered, hexagonal, and event-driven styles, naming one characteristic failure mode for each.

Trace a single create-order request end to end through your diagram and mark the three points of highest coupling.

Split a monolith scenario into at least 5 bounded contexts and justify each seam with a business capability, not a technical layer.

Define the contract (inputs, outputs, error codes, versioning rule) for 3 service interfaces and identify which are chatty.

Detect and name 4 decomposition anti-patterns in a sample design, such as distributed monolith, shared database across services, and cyclic dependency.

Decide and defend, in 5 bullet points, which 2 contexts must stay co-deployed and which 3 can be independently released.

Translate the context map into a logical data model with entities, keys, and cardinalities for at least 3 contexts.

Distinguish reference data, transactional data, and analytical data in your model and state the ownership rule for each.

Identify 3 places where a shared entity would create cross-context coupling and propose the duplicated-or-referenced alternative for each.

Write the service-to-service call sequence for one cross-context use case, including failure and compensation paths.

Compare synchronous request/response, asynchronous messaging, and batch for 4 integration scenarios and justify each pick in one sentence.

Specify idempotency, retry with backoff, and dead-letter handling for 2 write integrations, naming the exact key or token used.

Explain how you would keep 2 data stores consistent without distributed transactions, and state the acceptable staleness window.

Design the pagination, filtering, and error-payload conventions for one public-facing API and justify each choice.

Separate authentication from authorization in your design and place enforcement points at every entry boundary, including internal service calls.

Model roles, permissions, and data scopes for the order-management scenario and test 5 permission checks against the matrix.

Identify 4 places where a missing tenant or ownership filter would leak cross-tenant data and specify the guard for each.

Locate every secret, key, and credential in the design and state where each is stored, rotated, and never logged.

Write the audit and logging requirements for 3 sensitive operations, specifying what is captured, retention, and who can read it.

Choose a caching layer and invalidation rule for 2 read-heavy endpoints and state the maximum tolerable staleness.

Estimate where the design breaks first under 10x load and name the bottleneck resource with a reason.

Reconcile one security control with one performance target and document the trade-off you accept.

Describe how the solution scales horizontally and name which component requires state externalization to do so.

Map the lifecycle from development to production, listing the gates, environment promotion rule, and rollback trigger at each stage.

Define 4 observability signals (latency, error rate, saturation, queue depth) with a threshold that would page someone.

Identify 3 technical-debt items that would block a future scale-out and rank them by risk.

Take two timed full-length practice sets under exam conditions and log every miss by domain and error type (knowledge gap, misread, guess).

Re-teach your two weakest sub-topics from memory on blank paper, then verify against your notes and correct the gaps.

Reduce all five domains to a single-page decision cheat sheet of trade-off rules you can recall in under a minute.

Re-attempt every previously missed question and confirm you can justify the correct answer without seeing the old explanation.