Module 1: Exam Orientation and Strategy

Lesson 2: Scenario-based Reasoning Approach

In Lesson 1, we established that the CCA-F is a test of judgment. But how do you "Engineers" judgment? Professional AI architects use a Systematic Reasoning Framework. When faced with a 3-paragraph scenario involving conflicting requirements (e.g., "fast" but "cheap," "accurate" but "autonomous"), you cannot guess. You need a process.

In this lesson, we introduce the SCA Problem-Solving Algorithm. This 5-step framework will be your companion throughout this course and the final exam.

1. Step 1: Isolate the "Core Objective"

The first mistake students make is being distracted by "Technical Noise." A scenario might mention Docker, AWS, and Python, but the Core Objective might actually be "Reduce Latency."

How to Isolate the Goal:

Ask yourself: "If I could only fix ONE thing in this system, what does the user care about most?"

Is it Safety? (Preventing data leaks)
Is it Performance? (Sub-second response)
Is it Scalability? (Handling 10,000 users)
Is it Discovery? (Finding information in a large repo)

2. Step 2: Enumerate the "Hard Constraints"

A constraint is a non-negotiable limit. In the CCA-F, these are the "Guardrails" of the Answer. If an answer violates a hard constraint, it is wrong, even if it is technically brilliant.

Common Constraints in CCA-F:

The Financial Budget: "Must cost less than $0.01 per query." (Rules out Opus-only architectures).
The Tech Stack: "Must use the existing Postgres database." (Rules out switching to a Vector DB).
The User Privacy: "Data cannot leave the private cloud." (Rules out using 3rd party APIs).
The Time Limit: "Results must be generated within 5 seconds." (Rules out deep multi-step recursive loops).

3. Step 3: Map to Architectural Patterns

Once you have the goal and the constraints, you scan your "Pattern Library" (Modules 3-10) for the best fit.

Example Mapping:

Goal: high accuracy + Constraint: complex data -> Pattern: RAG + Claude 3.5 Sonnet.
Goal: low cost + Constraint: high volume -> Pattern: Claude 3 Haiku + Prompt Caching.
Goal: high reliability + Constraint: unreliable tools -> Pattern: Self-Correction Loops (Try-Check-Correct).

4. Step 4: Evaluate Trade-offs (The "Pareto Front")

This is the most critical step. Every architecture choice is a Trade-off.

If you add a "Supervisor Agent" to increase accuracy, you increase latency and cost.
If you use "Prompt Caching" to decrease cost, you might increase complexity in your backend code.

The Pareto Front mental model:

Imagine a graph with "Accuracy" on one axis and "Cost" on the other. The "Pareto Front" is the curve representing the best possible accuracy for a given cost. Your job as an architect is to find the point on that curve that satisfies the user's constraints.

5. Step 5: Final Justification

In the exam, you don't just pick "C." You pick "C" because: "Using a Supervisor-Worker pattern (C) satisfies the multi-domain expertise requirement while keeping the individual worker contexts lean enough to fit within the sub-second latency constraint, unlike the Monolithic approach (A)."

Practice Scenario:

"A fintech startup wants to use Claude to categorize 10,000 bank statements for tax reporting. The statements are sensitive and should not be stored permanently. The startup has a tiny budget but needs 99% categorization accuracy."

Deconstruction:

Core Objective: Categorize 10,000 statements.
Constraints: Sensitivity (Privacy), Tiny Budget (Cost), 99% Accuracy (High Intel).
Draft Choice: Haiku might be too cheap/dumb. Opus is too expensive.
The Architect's Selection: Use Claude 3.5 Sonnet + Prompt Caching (to lower costs of the categorization instructions) + Strict JSON Schema (to ensure accuracy/validation).

6. Summary

Reasoning is a skill that can be trained. By following the Isolate -> Enumerate -> Map -> Evaluate -> Justify algorithm, you remove the "Feeling" from the exam and replace it with "Logic."

In the next lesson, we will look at Domain Weightings, identifying which parts of this algorithm are most important for each section of the exam.

Interactive Quiz

What is a "Hard Constraint" in an architectural scenario?
Explain the "Trade-off" between Latency and Accuracy in a multi-agent system.
Why should you identify the "Core Objective" before looking at the technical implementation?
True or False: The most technically advanced solution is always the correct answer in CCA-F.

Reference Video: