AWS Certified Generative AI Developer - Professional:Bedrock Prompt Flows

Imagine you run a factory, not a wizard

tower. Raw materials come in all day

long. Some are clean, some are messy,

some are dangerous. You do not let raw

materials go straight to customers. You

build an assembly line. That assembly

line is a prompt flow. At the very start

of the factory, there's worker one.

Worker one does only one job. They

clean. They take whatever the user

sends, slang, emojis, broken sentences,

mixed languages, and they normalize it.

They don't answer anything. They don't

think, they just clean and standardize.

This is pre-processing. If the input is

unsafe, worker one raises a red flag and

sends it down a different hallway. That

hallway is conditional branching. Safe

input goes forward. Unsafe input gets

routed to a safety response. No debate,

no guessing. Next, the clean material

reaches worker two. Worker two is the

builder. This worker actually answers

the question. But here's the key. Worker

2 always follows the same rulebook. The

rules are fixed, the policies are fixed,

the tone is fixed. Only one thing

changes each time, the cleaned user

input. That's the static plus one

pattern. Static rules plus one dynamic

input. This keeps the system safe,

predictable, and auditable. Worker 2

never improvises beyond the rules.

Then the product reaches worker three.

Worker 3 is the inspector. They don't

care how clever the answer sounds. They

check structure. Is it valid JSON? Does

it contain all required fields? Does it

follow the approved format? If the

answer fails inspection, it never leaves

the factory. This is post-processing. No

schema rejected. Wrong format rejected.

Unsafe content rejected. Only approved

output ships. Now, zoom out. This entire

factory line is a prompt flow. Each

worker is a small reusable prompt. You

don't build one giant worker who does

everything. You build small workers with

clear responsibilities. Cleaner,

builder, inspector, and sometimes a

guard at the door who decides which path

to take. Why does AWS love this? Because

it's not magic. It's controlled. It's

testable. It's governable. It's

auditable. If something breaks, you know

which step failed. If something is

unsafe, it gets caught before shipping.

If rules change, you update one worker,

not the whole factory. Here's the rule

your brain should autoplay in the exam.

One big prompt is chaos. Many small

prompts is control. Messy input clean

first. Different cases branch. Untrusted

output validate. Fixed rules plus one

dynamic input. That's prompt flows, not

wizardry. Engineering.

Great. Let's do a real concrete

end-to-end prompt flow exactly how it

would exist in a production bedrock app.

No theory, no fluff, just what runs.

I'll show you. One, the flow. Two, the

actual prompts. Three, the inputs

outputs at each step. for why the exam

loves this pattern. Real prompt flow

example use case customer support AI

safe predictable auditable goal

normalize user input answer validate

output schema

hashed architecture mental picture this

could be orchestrated by bedrock prompt

flow or lambda step functions exam

accepts both step one normalize input

pre-processing user input messy

prompt one normalizer prompt template

history input variable

Output of step one. Why AWS loves this?

Clean input. No hallucination. No

business logic yet. Step two. Now we use

static plus one. Prompt two. Answer

generator. Static instructions.

Dynamic input + one.

Output of step two. Still not final.

This output is untrusted. Step three.

Validate output schema post-processing.

Now we make the output machine safe.

Prompt three validator prompt input

output of step three. Now it is

structured, predictable, safe to

integrate, logable.

Conditional branching real example.

Let's say step one detects abuse output

of step one. Alternate path

decision logic

safety prompt result. This is

conditional branching. Why the exam

loves this flow? This single flow

demonstrates pre-processing, static plus

one, sequential prompts, conditional

branching, post-processing, governance

and safety. If an exam question says

reduce hallucinations, improve safety,

and ensure structured output, this is

the correct mental model.