---
title: DynamoDB Vector Search GA (Aug 2026): When to Drop the Sync Pipeline
description: On August 5, 2026 DynamoDB GA’d native vector search — single-digit ms at 99%+ recall, up to 4096 dims, SearchVectors topK ≤ 100. Decision guide vs S3 Vectors, OpenSearch, and Bedrock Knowledge Bases.
url: https://www.factualminds.com/blog/amazon-dynamodb-vector-search-ga-2026/
datePublished: 2026-08-06T00:00:00.000Z
dateModified: 2026-08-06T00:00:00.000Z
author: palaniappan-p
category: Generative AI
tags: amazon-dynamodb, vector-search, rag, bedrock, agentic-ai, aws-ai
---

# DynamoDB Vector Search GA (Aug 2026): When to Drop the Sync Pipeline

> On August 5, 2026 DynamoDB GA’d native vector search — single-digit ms at 99%+ recall, up to 4096 dims, SearchVectors topK ≤ 100. Decision guide vs S3 Vectors, OpenSearch, and Bedrock Knowledge Bases.

On **August 5, 2026**, AWS [announced general availability of vector search for Amazon DynamoDB](https://aws.amazon.com/about-aws/whats-new/2026/08/amazon-dynamodb-vector-search/) — native approximate nearest neighbor (ANN) indexes so you can store embeddings next to operational attributes and call `SearchVectors` without replicating into a separate vector database. The companion [AWS News Blog walkthrough](https://aws.amazon.com/blogs/aws/amazon-dynamodb-now-supports-real-time-vector-search-at-any-scale/) positions **single-digit millisecond** latency at **99%+ recall**, up to **4,096 dimensions**, and design for **any scale** (including trillions of vectors), available in **all commercial Regions** and **AWS GovCloud (US)**.

If your product catalog, session store, or agent memory already lives in DynamoDB, this is the moment to ask whether the **OpenSearch / Pinecone / S3 Vectors sync pipeline** is still earning its keep. If your workload is corpus-scale RAG with wide recall and hybrid lexical search, it is not — keep [S3 Vectors](/blog/amazon-s3-vectors-native-vector-storage/) or OpenSearch Serverless for that lane.

> **Modeled comparison (not a cited client)** — Same product-catalog shape as the AWS News Blog sporting-goods example: **1M** items × **4 KB**, embeddings on `descriptionEmbedding`, **10 vector writes/s** + **10 `SearchVectors`/s**. Per the [DynamoDB pricing](https://aws.amazon.com/dynamodb/pricing/) on-demand vector example, AWS sketches **~$121.29/mo** total (**~$65.75** underlying table + **~$55.54** vector write/search/index storage at the published **$0.52/GB** write, **$0.002/GB** search, **$0.25/GB-mo** index rates). Architecture A keeps vectors in DynamoDB (no sync). Architecture B keeps ops in DynamoDB and mirrors embeddings to S3 Vectors or OpenSearch — you still pay DDB writes **plus** second-store ingest, drift monitoring, and dual failure modes. Architecture C uses Bedrock Knowledge Bases for document RAG and leaves DynamoDB for transactional keys only. The quantified outcome here is the **AWS published bill sketch** and the **removed sync pipeline**, not a FactualMinds engagement savings number.

---

## What shipped on August 5, 2026

| Capability | Detail |
| ---------- | ------ |
| Index type | Vector index on an embedding attribute (`List` of numbers) |
| Distance functions | Euclidean, Cosine, Dot product — match the embedding model |
| Dimensions | Up to **4,096** |
| Query API | `SearchVectors` — ranked similarity; **topK ≤ 100** |
| Partition key | Optional vector-index PK; each search scoped to **one** PK value |
| Filters | Inline **exact-match** attributes only |
| Capacity | **On-demand only** (Standard and Standard-IA table classes) |
| Quotas | Up to **5** vector indexes per table (raise via Support) |
| Global tables | Index definition replicates; ANN results may differ slightly by Region; indexing async |

Embeddings come from **your** model path — Bedrock Titan Text Embeddings, Cohere Embed, OpenAI, or anything else. DynamoDB stores the floats; it does not embed for you. Create the index via console, CLI, SDK, or CloudFormation after the attribute exists on items.

Developer reference: [Using vector indexes in DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/VectorSearch.html).

---

## Opinionated take: when DynamoDB wins vs when it does not

**Prefer DynamoDB vector search when:**

- Operational data **already** lives in DynamoDB (products, users, agent memory, recommendations state)
- You need **single-digit ms** semantic retrieval colocated with attributes in one response
- Candidate sets fit **topK ≤ 100**
- Filters are equality checks (`marketplace = US`, `category = footwear`)
- You will run the table **on-demand** and want to **delete the sync pipeline**

**Prefer another store when:**

| Need | Prefer |
| ---- | ------ |
| Wide recall / rerank (topK thousands) | [S3 Vectors](/blog/amazon-s3-vectors-native-vector-storage/) (up to **10,000** after June 2026) or OpenSearch |
| Hybrid BM25 + vector | OpenSearch Serverless vector engine |
| Managed chunking + ingestion for docs | [Bedrock Knowledge Bases](/blog/how-to-build-rag-pipeline-amazon-bedrock-knowledge-bases/) |
| Graph + vector in one query | [Neptune Analytics](/blog/amazon-neptune-analytics-graph-vector/) |
| Must stay on provisioned capacity | Separate vector store; do not block DDB FinOps on this feature |

**Trade-off we accept:** DynamoDB vector search optimizes for **colocated ops + ANN** and serverless ops simplicity. You give up hybrid search, wide topK, and provisioned-mode vector indexes. That is the correct trade for agent memory and product similarity; it is the wrong trade for enterprise document RAG with cross-encoder rerank pools.

> **Reproduce this** — Score your workload with [`examples/architecture-blog-2026/dynamodb-vector-search/vector-store-decision-matrix.md`](https://www.factualminds.com/examples/architecture-blog-2026/dynamodb-vector-search/vector-store-decision-matrix.md). Sum ≥ 14 → pilot DynamoDB vector search this sprint; 8–13 → split ops vs corpus stores; < 8 → keep the current vector path.

---

## Pricing dimensions (read the invoice correctly)

Vector search is **not** free with base table traffic. Per AWS pricing docs:

1. **Vector write requests** — GB written into the vector index (vector + projected attributes)
2. **Vector search** — GB processed to answer similarity search + data returned
3. **Vector index storage** — GB-month

Plus normal on-demand WRU/RRU and table storage. Operations bill **per byte** with a **1 KB minimum**. Global table replicated vector writes meter as vector write requests in the destination Region.

Re-check rates on the [DynamoDB pricing page](https://aws.amazon.com/dynamodb/pricing/) for your Region. For broader on-demand vs provisioned context (without vector), see [DynamoDB pricing: on-demand vs provisioned](/blog/amazon-dynamodb-pricing-on-demand-provisioned-gsi-streams/).

---

## Getting started shape (minimal)

Assumes: AWS CLI v2, on-demand table `ProductCatalog`, Titan Embeddings v2 (**1,024** dims), Cosine distance, partition key `marketplace`, filter `category`.

1. **Backfill** `descriptionEmbedding` as a `List` of numbers via `UpdateItem` (or embed on write going forward).
2. **Create vector index** — name, vector attribute, dimensions **1024**, Cosine, optional PK `marketplace`, filter attributes, projection.
3. **Wait** until index status is `Active`.
4. **Embed the query** with the **same** model, then call `SearchVectors` with topK (≤ 100), partition key value, and filters.

Similarity score semantics: for **Cosine** and **Euclidean**, **lower** is closer (0 = identical). For **Dot product**, **higher** is closer. Wire your UI and thresholds accordingly.

For single-table key design around the non-vector access patterns, see [DynamoDB single-table patterns for SaaS](/blog/dynamodb-single-table-design-patterns-for-saas/).

> **What broke** — Day one of a multi-marketplace catalog: team created a vector index **without** a partition key, then ran US and EU semantic searches against the full index under peak traffic. Latency stayed “fine” in the console demo on thousands of vectors and degraded as the catalog grew — every search examined one shared partition. Detection: rising `SearchVectors` latency and hot-partition CloudWatch metrics after backfill completed. Fix: recreate the index with `marketplace` as the vector index partition key and pass the marketplace on every search. Same week, a second team used **Euclidean** with a model trained for **Cosine** and watched recall collapse until the distance function matched the embedding training metric.

---

## Agent memory and RAG — do not force one store

DynamoDB already shows up as **agent memory** storage. Vector search adds **semantic retrieval over that memory** for grounding — short, hot, attribute-rich items with strict latency. That is different from **document RAG** over PDFs and wikis.

Recommended split:

- **Agent turns / tool results / user prefs** → DynamoDB + vector index
- **Knowledge corpus** → S3 + Bedrock Knowledge Bases (S3 Vectors or OpenSearch backend)
- **Fraud / graph neighborhood + similarity** → Neptune Analytics when structure matters

Fine-tuning vs RAG routing still applies: [Fine-tuning vs RAG on Bedrock](/blog/fine-tuning-vs-rag-bedrock-when-to-use/).

---

## What This Post Doesn't Cover

- **First-party latency benchmarks** in a FactualMinds account — numbers above are AWS-published claims and the pricing-page example, not our harness.
- **Full SDK samples** for every language — see the [developer guide](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/VectorSearch.html) and AWS MCP plugins for live API shapes.
- **Exact Regional rate tables** — use the pricing calculator / pricing page for your account; example dollars are illustrative US rates from AWS.
- **Migrating an existing Pinecone/OpenSearch corpus into DynamoDB** — usually a re-embed + dual-write cutover, not a dump/restore.

---

## What to Do This Week

1. **Score** the [vector store decision matrix](https://www.factualminds.com/examples/architecture-blog-2026/dynamodb-vector-search/vector-store-decision-matrix.md) — pilot if sum ≥ 14.
2. **Confirm** the candidate table is **on-demand** (or plan the capacity-mode change).
3. **Lock** embedding model, **dimensions**, and **distance function** before creating the index.
4. **Backfill** one attribute; create one vector index with a **partition key** and one exact-match filter; smoke `SearchVectors` with topK **5**.
5. **Compare** monthly cost of Architecture A (DDB-only) vs B (DDB + second vector store) using the AWS pricing example shape — if sync + dual store still exists only for ≤100-neighbor lookups, schedule decommission.

Need help choosing DynamoDB vs S3 Vectors vs OpenSearch for GenAI retrieval? FactualMinds is an AWS Select Tier Consulting Partner — [contact us](/contact-us/).

---

## Related reading

- [S3 Vectors: 10,000 Results per Query (June 2026)](/blog/amazon-s3-vectors-native-vector-storage/)
- [Amazon DynamoDB Pricing: On-Demand vs Provisioned](/blog/amazon-dynamodb-pricing-on-demand-provisioned-gsi-streams/)
- [DynamoDB Single-Table Design Patterns for SaaS](/blog/dynamodb-single-table-design-patterns-for-saas/)
- [How to Build a RAG Pipeline with Amazon Bedrock Knowledge Bases](/blog/how-to-build-rag-pipeline-amazon-bedrock-knowledge-bases/)
- [Amazon Neptune Analytics: Graph + Vector](/blog/amazon-neptune-analytics-graph-vector/)
- [Fine-Tuning vs RAG on Bedrock](/blog/fine-tuning-vs-rag-bedrock-when-to-use/)

## FAQ

### What did AWS ship for DynamoDB vector search on August 5, 2026?
General availability of native vector indexes on DynamoDB tables. You store embeddings as a List of numbers on items, create a vector index (dimensions, distance function, optional partition key, exact-match filters), and call SearchVectors for approximate nearest neighbor results. AWS positions single-digit millisecond latency at 99%+ recall, up to 4096 dimensions, Euclidean/Cosine/Dot product metrics, and availability in all commercial Regions plus AWS GovCloud (US).

### When should I NOT use DynamoDB vector search?
Skip it when you need (1) topK greater than 100 for wide-recall rerank pipelines — use S3 Vectors (up to 10,000 as of June 2026) or OpenSearch, (2) hybrid BM25 + vector search, (3) range filters like BETWEEN on metadata, (4) a provisioned-capacity table you cannot move to on-demand, or (5) a large document corpus with managed chunking — prefer Bedrock Knowledge Bases on S3 Vectors or OpenSearch Serverless.

### Does vector search work with provisioned capacity?
No. Vector indexes require on-demand capacity mode. If you are on provisioned for FinOps reasons, either migrate the table to on-demand before creating a vector index or keep vectors in a separate store. Global tables that use on-demand can carry vector indexes; the index definition replicates with the table.

### How is DynamoDB vector search priced?
Three add-on dimensions on top of normal table WRU/RRU and storage: vector write requests (GB written into the index), vector search (GB processed and returned), and vector index storage (GB-month). Billing is per byte with a 1 KB minimum. AWS’s published on-demand example for 1M 4 KB items at 10 writes/s and 10 searches/s totals about $121.29/mo ($65.75 table + $55.54 vector) in the pricing page rates shown — re-check your Region before budgeting.

### What could go wrong after enabling a vector index?
Common failures: choosing Cosine when your embedding model was trained for Dot product (recall collapses), omitting the vector index partition key on large datasets so every search hits one hot partition, assuming filter attributes support BETWEEN or BEGINS_WITH (exact-match only), expecting identical SearchVectors ordering across Global Table Regions (ANN + async indexing), and treating SearchVectors like a GSI Query with sort keys.

### Can I use Bedrock embeddings with DynamoDB vector search?
Yes. Generate embeddings with any model — including Amazon Titan Text Embeddings, Cohere Embed, or OpenAI models via Bedrock or elsewhere — then PutItem/UpdateItem the List of floats onto the item. Match index dimensions and distance function to the model. DynamoDB does not call Bedrock for you; you own the embed-on-write path.

### How does this compare to S3 Vectors for RAG?
DynamoDB vector search wins when operational attributes and vectors must stay colocated with single-digit ms retrieval and topK ≤ 100. S3 Vectors wins for corpus-scale RAG, Bedrock Knowledge Bases backends, and wide candidate pools (up to 10,000 results per query after June 2026) at higher latency tolerance. Many architectures keep carts/sessions/agent memory in DynamoDB and document chunks in S3 Vectors — do not force one store for both.

---

*Source: https://www.factualminds.com/blog/amazon-dynamodb-vector-search-ga-2026/*