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.

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:

The four essential elements every effective Nova prompt needs

The boilerplate Nova prompt structure you’re looking for:

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:

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:

And here’s a complex reasoning template:

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)

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

3. System-Level Format (Best for complex 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)

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

3. Format Template (Best for simple structures)

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

2. Mixed Media Comparison

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:

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

Editing Operations:

1. Inpainting (Editing Parts of Images)

2. Outpainting (Extending Images)

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:

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:

Image-to-Video Generation:

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.

Site Terms, Privacy, and more.