Amazon Nova Micro: The Fastest Text Model on AWS Bedrock

Updated
7 min read
Amazon Nova Micro: The Fastest Text Model on AWS Bedrock
TL;DR

Nova Micro is Amazon's text-only model with sub-millisecond time-to-first-token and a $0.035/1M input price - designed for high-volume classification, extraction, and routing pipelines inside AWS infrastructure.

What Nova Micro Is Built For

Nova Micro is not designed to compete with GPT-4o or Claude 3.5 Sonnet on reasoning tasks. It is engineered for one purpose: the highest possible throughput at the lowest cost for simple text tasks that do not require image understanding or complex reasoning.

The target workloads:

  • Classification - route support tickets, categorize emails, classify intent
  • Extraction - pull structured fields from unstructured text
  • Routing - determine which specialized model or queue to send a request to
  • Simple Q&A - answer questions from a provided context passage
  • Filtering - determine if content meets criteria before expensive processing

For these tasks, Nova Micro's sub-millisecond time-to-first-token (TTFT) changes what is architecturally possible - you can run it synchronously in a request path without adding perceptible latency.

Pricing

Click any column to sort
4 rows
Nova Micro$0.035$0.140128k
Nova Lite$0.060$0.240300k
Nova Pro$0.800$3.200300k
Claude 3 Haiku$0.250$1.250200k

Nova Micro is roughly 7x cheaper than Claude 3 Haiku for input tokens - the cheapest general-purpose LLM available on AWS Bedrock.

Using Nova Micro via Bedrock SDK

python
import boto3
import json

bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")

def classify_intent(user_message: str) -> str:
    response = bedrock.invoke_model(
        modelId="amazon.nova-micro-v1:0",
        body=json.dumps({
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {
                            "text": f"""Classify this customer message into one category.
Categories: BILLING, TECHNICAL, SHIPPING, RETURNS, OTHER

Message: {user_message}

Respond with only the category name."""
                        }
                    ]
                }
            ],
            "inferenceConfig": {
                "maxTokens": 10,
                "temperature": 0.0,
            }
        }),
    )
    result = json.loads(response["body"].read())
    return result["output"]["message"]["content"][0]["text"].strip()

# Example usage
intent = classify_intent("I was charged twice for my order last week")
print(intent)  # BILLING

Cascaded Routing Pattern with Nova Pro

The most cost-effective pattern on Bedrock is cascaded routing: use Nova Micro to classify complexity, then route hard requests to Nova Pro.

python
def intelligent_route(user_query: str) -> str:
    # Step 1: Nova Micro classifies complexity (cost: ~$0.000035 per call)
    complexity_check = bedrock.invoke_model(
        modelId="amazon.nova-micro-v1:0",
        body=json.dumps({
            "messages": [{"role": "user", "content": [{"text": f"""Is this query simple or complex?
Simple: factual questions, short extraction, yes/no answers
Complex: multi-step reasoning, analysis, synthesis, long generation

Query: {user_query}
Answer with one word: SIMPLE or COMPLEX"""}]}],
            "inferenceConfig": {"maxTokens": 5, "temperature": 0.0},
        }),
    )
    complexity = json.loads(complexity_check["body"].read())["output"]["message"]["content"][0]["text"].strip()

    # Step 2: Route accordingly
    if complexity == "SIMPLE":
        model_id = "amazon.nova-micro-v1:0"  # $0.035/1M
    else:
        model_id = "amazon.nova-pro-v1:0"    # $0.800/1M

    # Step 3: Generate actual response
    response = bedrock.invoke_model(
        modelId=model_id,
        body=json.dumps({
            "messages": [{"role": "user", "content": [{"text": user_query}]}],
            "inferenceConfig": {"maxTokens": 1024},
        }),
    )
    return json.loads(response["body"].read())["output"]["message"]["content"][0]["text"]

In practice, 60 - 80% of support queries are "simple" by this definition. A pipeline that routes correctly saves 20x on model costs for those queries.

Batch Inference on Bedrock

For non-latency-sensitive workloads (nightly report processing, weekly data enrichment), Bedrock Batch Inference applies additional discounts (up to 50% off) and removes the need to handle rate limits:

python
bedrock_client = boto3.client("bedrock", region_name="us-east-1")

job = bedrock_client.create_model_invocation_job(
    modelId="amazon.nova-micro-v1:0",
    jobName="nightly-classification-job",
    inputDataConfig={"s3InputDataConfig": {"s3Uri": "s3://my-bucket/input/"}},
    outputDataConfig={"s3OutputDataConfig": {"s3Uri": "s3://my-bucket/output/"}},
)
#amazon-nova-micro#aws#speed#cost#text-only

One AI engineering post, weekly

LLM benchmarks, prompt techniques, and token-cost breakdowns, delivered to your inbox.

What should we test or explain next?

Comments

Have a question or something to add? Sign in to join the discussion.

Mahmudul Haque Qudrati — CEO & ML Engineer at Pristren

Mahmudul Haque Qudrati

CEO & ML Engineer

Software architect, full-stack engineer, and machine learning practitioner. Founder & CEO of Pristren, CTO at Venture Kick-backed PIN Sport Application GmbH (Basel, Switzerland), Software Development Lead at DailyFrame GmbH (building Dimetra patient transport software), and creator of Zlyqor. Focused on custom workflow automation, scalable web and mobile applications, and production AI/ML systems.