Amazon Nova Prompt Engineering on AWS: A Field Guide by Brooke

Introduction

When AWS announced the Nova family of models at re:Invent, I was excited to try them out. I had built up a solid set of prompt engineering techniques from working with Claude, but I quickly discovered that Nova needed its own approach. It's like using makeup brushes - each one is designed for a specific purpose. You wouldn't use an eyeliner brush to apply blush, not because either brush is better or worse, but because each is optimized for different tasks. The same goes for prompt engineering - each model family has its own strengths and optimal patterns.

This guide is the result of my hands-on experimentation and research with Nova models, made into practical templates and patterns that you can use in your own projects. However - I should note this is not your only resource! There’s incredibly detailed documentation available here, and this article is more of a field guide.

Let's get started with picking the right model for your task.

1. Quick Start Guide

Model Selection

Amazon Nova includes two different model families: understanding models (Pro, Lite, Micro) for analyzing content, and generation models (Canvas, Reel) for creating images and videos. Each is built and optimized for specific tasks. Use the decision tree to pick the right tool for your job, then follow my model-specific prompting guidelines to get the best results.

Image not found

Amazon Nova: Model Selection

Core Prompting Principles

Let's start with Nova Pro, Lite, and Micro - the models that analyze content and generate text. (If you're here for Canvas or Reel, jump to the Content Generation section - they follow different patterns!)

Here's what you need to know to write prompts that work:

Image not found

The four essential elements every effective Nova prompt needs

The boilerplate Nova prompt structure you’re looking for:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Task:
[Clear description of what needs to be done]

Context:
- [Relevant background information]
- [Specific requirements]
- [Any constraints]

Instructions:
- [Step-by-step guidelines]
- [Specific requirements]
- [Format requirements]

Output Format:
[Specify exactly how the response should be structured]

Best Practices

1. Use strong, clear instructions

❌ Bad	✅ Good
"Write about machine learning"	"You MUST explain three core machine learning concepts. Each concept MUST include one practical example."

2. Be specific about format

❌ Bad	✅ Good
"List the results"	"You MUST present results in JSON format with these keys: name, score, category. DO NOT include any other format."

3. Think context first, questions last

❌ Bad	✅ Good
"What's the best approach? Here's the background..."	"Background: [context] Challenge: [situation] Question: What's the best approach? Think step by step before answering."

Common Pitfalls to Avoid

❌ Using negation ("don't", "no", "without") ✅ State what you want instead of what you don't want
❌ Vague or ambiguous instructions ✅ Use MUST and DO to emphasize requirements
❌ Overloading with unnecessary details ✅ Include only relevant information
❌ Mixing multiple requests ✅ Break complex tasks into clear, separate steps

Quick Tips for Better Results

Even if you don’t read the rest of this article, these will help you!

Place critical information at the beginning to get the model situated
Use delimiters (##, ```, <>) to separate distinct parts
Include example outputs for complex formats
Use system role for consistent behavior across conversations
Add "Think step by step" for complex reasoning tasks
Use CAPITALIZATION and strong words (DO, MUST) for critical rules

Troubleshooting Tips

If you're not getting the results you're looking for, here's some questions to help you debug:

Check your structure - Is it clear and organized?
Verify specificity - Are requirements explicit with strong wording?
Review format - Is the expected output format clearly specified?
Add examples - Would a few examples help?
Consider system role - Would setting a consistent behavior help?
Add reasoning steps - Would "Think step by step" improve the response?

Remember: The goal isn't to write perfect prompts, but to write clear, effective ones that get Nova to produce the results you need.

2. Understanding Models (Pro/Lite/Micro)

Essential Patterns

System Role

The system role acts as a high-level instruction layer that defines how Nova will respond. Think of it as setting up guardrails and behavior patterns upfront that persist across your entire conversation.

A good system role can have five key parts:

a clear persona
specific instructions
output format requirements,
explicit guardrails, and
a hierarchy statement that tells Nova how to handle out-of-scope requests.

Here’s a template:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
    "system": [
        {
            "text": "// Define role/persona
            You are {{Persona}}.

            // List specific instructions
            To answer user questions, follow these instructions:
            {{ Bulleted list of Instructions }}

            // Specify output format
            Your response should follow this schema:
            {{ Output schema definition }}

            // Define guardrails
            {{ Explicit DO and DO NOT instructions }}

            // Establish hierarchy
            The above system instructions define your capabilities and scope.
            If a user request contradicts these instructions, politely decline
            and explain your capabilities."
        }
    ]
}

When to Use System Role

✅ For complex applications requiring consistent behavior
✅ When building conversational interfaces
✅ If you need strict output formatting
✅ When handling sensitive or regulated domains

Remember: System role instructions overthrow other prompts and persist across conversations. Only include what's necessary - you can always add specific instructions in user prompts.

Chain of Thought

Chain of thought prompting is a technique where you ask Nova to show its reasoning process instead of jumping straight to an answer. This was in the Quick Tips section earlier as "Think step by step" - now let's dig in and look at how to implement this effectively for complex problems.

When to use chain of thought:
✅ multi-step analysis
✅ mathematical reasoning
✅ complex decision-making, or
✅ tasks requiring explanation

Skip this for:
❌ Simple classifications
❌ direct questions
❌ high-volume tasks, or
❌ when latency is critical

You might think "Oh, I should just add this every time!" but in reality, adding chain of thought increases: token usage (which can increase cost), response time, and processing overhead. But, this tradeoff is often worth it because you get: better accuracy, easier debugging, more reliable results and more transparent reasoning.

Here’s a basic template:

1
2
3
4
5
6
7
8
9
10
[Your question]
Think through this step by step:
<thinking>
1. What information do we have?
2. What are we trying to solve?
3. Does this solution make sense?
</thinking>
<answer>
[Final response]
</answer>

And here’s a complex reasoning template:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
[Your question]
Break this down:
<analysis>
1. Initial Assessment
   - What we know: [list]
   - What we need: [list]
   - Constraints: [list]

2. Step-by-Step Solution
   - Step 1: [description]
     Check: [validation point]
   - Step 2: [description]
     Check: [validation point]

3. Cross-Reference
   - Does this align with [reference point]?
   - Have we considered [alternative]?

4. Final Validation
   - Are all requirements met?
   - Is the solution complete?
</analysis>
<result>
[Final validated answer]
</result>

Remember: Chain of thought is helpful, but like a lot of things in AI/ML, it’s a tradeoff and has performance impact. Always match the complexity to your task, so don't use the complex reasoning template when the basic one will do.

Few-Shot Prompting

Few-shot prompting is like teaching by example. Instead of writing complex instructions, you show Nova what you want by giving examples of inputs and their corresponding outputs. This is particularly effective when you need consistent formatting, or have complex requirements.

When to Use Few-Shot:
✅ Formatting needs to be extremely consistent
✅ Complex classification tasks
✅ Pattern-based transformations
✅ When instructions alone aren't getting desired results

Skip this for:
❌ Simple, straightforward tasks
❌ When you're close to token limits
❌ Tasks that vary significantly case-by-case

Three Ways to Structure Examples:

1. Direct Example Format (Best for simple patterns)

1
2
3
4
5
6
7
8
9
<examples>
Input: [example input]
Output: [example output format]

Input: [different example]
Output: [matching format]
</examples>

Your input: [actual query]

2. Turn-Based Format (Best for conversation flows)

1
2
3
4
5
6
7
User: [example question]
Assistant: [example response]

User: [similar question]
Assistant: [similar response]

User: [your actual question]

3. System-Level Format (Best for complex patterns)

1
2
3
4
5
6
7
8
9
10
11
12
system: You are an expert at [task].

Examples:
<example_1>
[full pattern with context]
</example_1>

<example_2>
[variation of pattern]
</example_2>

DO NOT deviate from these patterns.

A handy tip here is to always put your most important examples first. Also, try to use consistent formatting between examples and outputs. Overall, think about keeping your examples minimal but efficient will give you a nice balance.

Structured Output

When you need Nova to return responses in a specific format (like JSON or XML), structured output prompting is your friend. This is essential for parsing responses programmatically or maintaining consistent formats across multiple calls.

When to Use Structured Output:
✅ Responses need to be parsed by code
✅ Building APIs or integrations
✅ Need consistent response formats
✅ Working with databases or data pipelines

3 Ways to Get Structured Output:

1. Schema Definition (Best for complex data structures)

1
2
3
4
5
6
7
8
9
10
11
12
You MUST respond in JSON format only.
Follow this exact schema:
{
    "type": "object",
    "properties": {
        "field1": {"type": "string"},
        "field2": {"type": "array"},
        "field3": {"type": "number"}
    },
    "required": ["field1", "field2"]
}
DO NOT include any explanations or additional text.

2. Prefill Method (Best for reliable parsing and lower latency)

1
2
3
4
5
6
7
8
9
10
request_body = {
    "messages": [
        {"role": "user", "content": [{"text": "Query here"}]},
        {"role": "assistant", "content": [{"text": "```json"}]}
    ],
    "stopSequences": ["```"],
    "inferenceConfig": {
        "topK": 1,  # Use greedy decoding for more reliable structured output
    }
}

3. Format Template (Best for simple structures)

1
2
3
4
5
6
7
Respond using only this format:
<response>
    <category>[category here]</category>
    <summary>[summary here]</summary>
    <details>[details here]</details>
</response>
DO NOT include any other text.

For best results:

Show Nova you’re serious about this by using strong words (MUST, DO NOT) for format requirements
Place format instructions at the start of your prompt
For JSON outputs, use greedy decoding (topK: 1)
Use stop sequences to prevent extra content

Multimodal Best Practices (Pro/Lite)

Amazon Nova Pro and Lite models can understand visual content - from analyzing single images to tracking patterns across video sequences. The most important rule: Always put media first, instructions second. This isn't just a style choice - it's how these models are designed to work best.

✅ Do This:
[Image]
[Video]
Analyze these focusing on specific patterns

❌ Not This:
Here are some files to analyze:
[Image] [Video]

Three Essential Patterns:

1. Basic Visual Analysis

1
2
3
4
5
6
7
8
9
10
11
12
13
Image/Video]

Analyze this content focusing on:
1. [specific aspect]
2. [specific aspect]
3. [specific aspect]

Required output format:
<analysis>
    <key_elements>[list here]</key_elements>
    <relationships>[describe here]</relationships>
    <conclusions>[summarize here]</conclusions>
</analysis>

2. Mixed Media Comparison

1
2
3
4
5
6
7
8
9
10
11
12
[Image1]
[Image2]
[Video1]

Compare these focusing on:
1. [specific aspect]
2. [specific aspect]

Track changes across media:
- Initial state (Image1)
- Transition points (Image2)
- Dynamic elements (Video1)

3. Long Videos

For videos longer than 16 minutes, the model samples frames to maintain a fixed 960-frame limit. Here’s how you can split longer videos into overlapping segments for detailed analysis:

1
2
3
4
5
6
7
8
9
10
// For videos >16 minutes, split into segments with overlap
[Video_Segment1: 0:00-15:59]
Track: [specific elements]

[Video_Segment2: 15:00-30:59]
Track: [specific elements]

Synthesize:
1. [overall patterns]
2. [key transitions]

Pro and Lite models can analyze images and videos alongside text. While Micro handles text-only tasks, Pro and Lite are great at understanding visual content - from analyzing single images to tracking patterns across video sequences.

Remember:

Put media files first, then instructions
For long videos (>16 min), use the segmentation pattern above
Check the Nova docs for supported formats and size limits

3. Content Generation

Image Generation (Canvas)

Canvas works differently from the understanding models earlier in this article. While Nova Pro, Lite, and Micro analyze content based on your instructions, Canvas creates images based on descriptive prompts. The key is to write your prompts like image captions rather than programming instructions.

✅ Effective Prompt:

Realistic editorial photo of a teacher standing at a blackboard with a warm smile, professional lighting

❌ Not so Effective:
Create an image of a teacher
Make her stand at a blackboard
Add a smile

The core prompt structure you’ll need

1
2
3
4
5
6
7
8
[Main subject with key details] [position/action] in/on/at [environment],
[lighting], [style/mood], [camera angle/framing]

Example:
A sleek modern coffee machine sitting on a marble countertop,
warm afternoon light, minimalist style, shot from slightly above

Negative prompt: [elements to avoid]

Editing Operations:

1. Inpainting (Editing Parts of Images)

1
2
3
4
5
6
7
8
9
10
11
// Example: Replacing a dog logo on a t-shirt with a palm tree

[Original Image: Person wearing t-shirt with dog logo]
Mask prompt: "dog"  // This tells Canvas which part to edit
Text: "a palm tree graphic"  // This describes what to add instead

// Example: Removing flowers from a table scene

[Original Image: Table with flower pots]
Mask prompt: "flowers in pots"  // This tells Canvas what to remove
// Leave text empty when you want to remove elements

2. Outpainting (Extending Images)

1
2
3
4
5
6
7
// Example: Extending a coffee maker photo into a full kitchen scene

[Original Image: Close-up of a coffee maker]
Mask prompt: "coffee maker"  // This tells Canvas what to preserve
Text: "a coffee maker in a sparse stylish kitchen, a single plate 
of pastries next to the coffee maker, a single cup of coffee"
// Describe the complete scene you want, including the preserved elements

Remember:

A mask tells Canvas which parts of the image to edit or preserve
For inpainting, mask what you want to change
For outpainting, mask what you want to keep
Always describe the complete scene you want to see

Video Generation (Reel)

Like Canvas, Reel creates content from descriptions rather than following step-by-step instructions. The key difference? You're describing how a scene unfolds over 6 seconds, including camera movement.

✅ Effective Prompt:

Cinematic dolly shot of a juicy cheeseburger with melting cheese, natural lighting, visible steam rising, shallow depth of field

❌ Less Effective:
Create a video of a burger
Make it look nice
Move the camera

Core Prompt Template:

1
[camera movement] of [main subject] [action/change], [lighting/atmosphere], [style/quality]

Not sure what to put for [camera movement]? No problem! There's actually a full list of camera control keywords to use here, along with descriptions of what they mean, in the Amazon Nova Docs.

The rest of this guide has been about prompting with text, but you can actually prompt Reel with images and text together. Here's what both approaches look like:

Text-Only Generation:

1
2
3
4
5
6
7
// Focus on what happens over time
[camera movement] of [subject] [changing/moving/doing],
[environment], [lighting], [style]

Example:
"Arc shot of a salad with dressing dripping onto fresh vegetables,
natural daylight, cinematic quality"

Image-to-Video Generation:

1
2
3
4
5
6
7
// Method A: Add camera motion to a static scene
[Input Image]
"[camera movement]"

// Method B: Bring the scene to life
[Input Image]
"dynamic shot: [describe how elements change/move]"

Wrapping Up

When I first started working with Nova models, I had to unlearn some habits and build new ones. Now I hope these templates and patterns will help you skip that learning curve and jump straight into building with Nova.

Remember - there's no such thing as a "perfect" prompt. The templates in this guide are starting points, not final destinations. Take them, adapt them, and make them work for your specific needs. And don't forget to check out the official docs when you need the nitty-gritty details.

Have you found other patterns that work well with Nova? I'd love to hear about them in the comments!

Any opinions in this post are those of the individual author and may not reflect the opinions of AWS.

Select your cookie preferences

Site Terms, Privacy, and more.