What Nova Micro Is Built For

One AI engineering post, weekly

LLM benchmarks, prompt techniques, and token-cost breakdowns — not another AI news roundup.

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

Model	Input ($/1M)	Output ($/1M)	Context
Nova Micro	$0.035	$0.140	128k
Nova Lite	$0.060	$0.240	300k
Nova Pro	$0.800	$3.200	300k
Claude 3 Haiku	$0.250	$1.250	200k

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

Team workspace

Ship faster with chat, meetings, and projects in one place — Zlyqor.

Start free

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/"}},
)

Links

AWS Bedrock pricing

#amazon-nova-micro#aws#speed#cost#text-only

Mahmudul Haque Qudrati

CEO & ML Engineer

Visionary technologist, software engineer, and machine learning specialist. Founder and CEO of Pristren, directing engineering teams that ship production-grade AI/ML pipelines, mission-critical full-stack applications, and developer tooling. Creator of Zlyqor, the unified team workspace platform. Author of 540+ technical guides and benchmark research reports on large language models, agentic workflows, Model Context Protocol (MCP), and modern web stacks.