Workflow Sub-Patterns for the CCAR-P Exam

Four ways to fix a control flow

Once a problem calls for a workflow, a fixed, human-designed sequence of calls, the next question is which workflow shape fits. The Claude Certified Architect - Professional (CCAR-P) exam treats the four sub-patterns as an understand-level skill because they are frequently confused, and choosing the wrong one produces a control flow that fights the task's structure. Prompt chaining, routing, parallelization, and evaluator-optimizer each encode a different relationship among the steps: sequential dependence, mutually exclusive paths, independent concurrency, and generate-then-check. Matching the shape to how the sub-tasks actually relate is the skill.

All four are workflows, so the sequence in each is predetermined by the designer, not chosen by the model at runtime. What differs is the topology of the steps. Getting that topology right is what separates a workflow that flows naturally from one that forces the work into the wrong structure.

The four are not mutually exclusive. Most production workflows combine more than one, a router that dispatches to several chains, or a parallelized fan-out whose aggregate is then wrapped in an evaluator-optimizer check, and the reliable move is to reach for the simplest composition that meets the task's error tolerance and observability needs rather than the most elaborate one available. Treat the choice as revisable: ship the simpler shape, measure it against production data, and escalate to a heavier composition only when the measurement shows the simpler pattern falling short.

Chaining and routing

Prompt chaining fits a task that is genuinely a sequence: extract fields, then classify the result, then summarise, where each step consumes the previous step's output and the order is fixed in advance. It is the right shape when the sub-tasks have a strict dependency chain, one thing must happen before the next can, and the sequence is known at design time.

Routing fits a task that splits into mutually exclusive paths. An initial classification step labels the request, and based on the label the request is sent down exactly one of several fixed paths, as in ticket triage where a billing question and a technical question take different handlers. The defining property is one-of-many: each request follows a single path chosen by the classification, and the paths are distinct enough that classifying between them is meaningful.

Parallelization and evaluator-optimizer

Parallelization fits a task whose sub-tasks are independent and can run at once. Several sub-tasks execute concurrently and their results are aggregated, which reduces latency compared with doing them one after another. The defining property is many-at-once: the request needs multiple pieces of work done in parallel, not one path selected. This is precisely where routing is often mistakenly chosen, because both involve multiple possible pieces of work, but routing picks one and parallelization runs many.

Evaluator-optimizer fits a task where output quality can be checked against a rubric. A generation step produces a candidate, an evaluator step checks it, and if it fails, the generation is refined and re-checked until it passes. The defining property is a checkable rubric: the evaluator has to be able to judge correctness, or the check is empty. On a task with no checkable rubric, the evaluator step cannot actually judge the output, which is the pattern's failure mode.

What the CCAR-P exam trips candidates on

The exam tests two traps. The first is choosing routing when the real need is parallelization, because the request needs multiple paths at once, not one path chosen. A scenario will describe work that requires several independent pieces done concurrently, and the trap is to reach for routing because both patterns involve multiple candidate paths. The credited answer notices the sub-tasks are independent and simultaneous, which is parallelization, not routing's one-of-many selection.

The second is using evaluator-optimizer for a task with no checkable rubric, producing an evaluator step that cannot actually judge correctness. A scenario will apply a generate-then-check loop to output whose quality is a matter of judgment, and the reliable reading recognises that without a rubric the evaluator is decorative, and either a different pattern or a human-escalation path is needed.

Common misreadings to avoid

How this shows up on the exam

Domain 1 questions on this knowledge point describe a task's step structure and ask which workflow sub-pattern fits, or critique a mismatched one. The reliable reading reads the topology: sequential dependence is chaining, one-of-many is routing, many-at-once is parallelization, and generate-then-check with a real rubric is evaluator-optimizer, and it rejects evaluator-optimizer where no checkable rubric exists.

These sub-patterns expand the workflow point on the autonomy spectrum. Evaluator-optimizer is also the automated mechanism in designing the feedback loop, and the sequencing judgement behind chaining and parallelization is the same one at work in dependency ordering in decomposition.