Every team I have worked with hates PostgreSQL and MySQL maintenance. It does not matter how you run it, self managed or fully managed, it always comes with downtime. Someone breaks an index and causes an outage. And let’s not even talk about the DDL change that ran fine in test, then hung the production database during peak traffic.
But the minute someone proposes DynamoDB, the room changes. Everyone starts worrying about the heavy lift: reworking the application, rethinking every query, and moving column data into JSON or Ion payloads to store as items. The migration looks bigger than the pain, so it goes back in the backlog.
So next month the team suffers through another database upgrade. And another DDL outage.
The case for DynamoDB on high scale read and write paths was never the problem. You get consistent single digit millisecond latency, data replicated across multiple Availability Zones, and on demand capacity with no servers to patch. The problem was the work. What has changed is that GenAI coding tools now make most of that work cheap. They do not make the judgment calls cheap, and that is where I want to spend most of this post.
Why teams avoided it
Two things kept this migration in the backlog.
First, single table design forces you to think in access patterns instead of joins. In SQL you normalize the data and let the query planner figure out the rest. In DynamoDB you list every question the application asks, then design partition keys, sort keys, and global secondary indexes (GSIs) so each question is answered by a single Query or GetItem. That is a different mental model, and most teams have never written their access patterns down.
Second, the data access layer rewrite is long and boring. Every repository method, ORM call, and hand tuned query has to be translated. On a mature codebase that was months of work, and months of work with no new features is a hard sell.
The AWS Prescriptive Guidance on modernizing RDBMS to DynamoDB lays out this process in detail, and it is honest about how much of it is analysis rather than code.
The zero downtime pattern
The cutover pattern itself is well understood. The steps:
- Full load plus change data capture. AWS DMS copies the existing data and then streams ongoing changes from the source into DynamoDB. The DMS MySQL to DynamoDB walkthrough covers the object mapping you need to reshape rows into items.
- Dual writes behind a feature flag. The application writes to both systems. SQL stays the source of truth.
- Shadow reads. Serve from SQL, also read from DynamoDB, compare results, and log every mismatch. This is where you find the access pattern you forgot.
- Gradual cutover. Move reads to DynamoDB by percentage or tenant, then flip the source of truth, then retire the dual write.
There is now a better managed option for the backfill step. On November 5, 2026, AWS made bulk put items for DynamoDB generally available. You export your transformed data to S3, point bulk put items at it, and DynamoDB writes it into your existing table without impacting live workloads. The key detail for migrations: each item can carry its own condition expression. That means you can run the backfill as insert only (attribute_not_exists(PK)) so it never overwrites a fresher record from CDC or dual writes, or use a version guard so only older data loses. AWS lists backfills and migrations as explicit use cases, and the November 9 weekly roundup highlights it too. I would use it for the historical backfill and keep CDC or dual writes for live changes.
Where GenAI actually helps
This is where the cost curve bends. Four jobs that used to eat weeks are now hours of review:
- Building the access pattern inventory. Feed the model your slow query log, ORM call sites, and API routes. It will cluster them into a list of patterns with frequency and latency targets. You still review it, but you are editing, not writing.
- Drafting key designs and GSIs. Given the inventory, the model proposes partition keys, sort key prefixes, and GSI overloading. Treat this as a first draft from a junior engineer who read every DynamoDB talk.
- Generating the repository layer rewrite. Interface stays the same, implementation swaps. This is mechanical translation, which is exactly what these tools are good at.
- Producing parity tests and reconciliation scripts. Shadow read comparators, row count checks, and checksum jobs are tedious to write and easy to verify.
A version guarded write the copilot might draft for the dual write path:
table.put_item(
Item={"PK": f"ORDER#{order_id}", "SK": "META", "version": new_version, **attrs},
ConditionExpression="attribute_not_exists(PK) OR version < :v",
ExpressionAttributeValues={":v": new_version},
)
Hype check: where AI does not help
Deciding which access patterns matter is a business decision. The model can list what the code does today. It cannot tell you which patterns the product will need next year, which ones carry revenue, or which can tolerate eventual consistency. It will also confidently design a hot partition. I have watched a copilot propose STATUS#OPEN as a partition key for an orders table, which sends every open order to one partition. Reviewing key cardinality is still your job.
Transactions and ad hoc reporting may stay in SQL. DynamoDB supports transactions, but if a workflow depends on complex multi table transactions or analysts running arbitrary joins, forcing it into DynamoDB is a mistake. The hybrid design guidance is explicit that keeping both is a valid architecture. Reporting can flow to an analytics store through zero ETL integrations instead.
Search is the wrong job for DynamoDB. A Scan reads the whole table, which is slow and billed by the data read. AI tools love writing Scans because a Scan with a filter works perfectly on a 500 row dev table. In production it becomes your biggest bill and your worst p99. The right pattern: stream data into OpenSearch through the DynamoDB zero ETL integration or Streams plus a pipeline, run the search there, return only primary keys, then fetch the authoritative record with GetItem or BatchGetItem.
flowchart LR
App[Application] -->|writes| DDB[(DynamoDB table)]
DDB -->|DynamoDB Streams / zero ETL integration| OS[(OpenSearch index)]
App -->|1. search query: text, attributes| OS
OS -->|2. returns matching primary keys only| App
App -->|3. GetItem / BatchGetItem by key| DDB
DDB -->|4. authoritative item, single digit ms| App
OpenSearch finds the item, DynamoDB serves the item. Never Scan the table to search.
The index can lag slightly behind the table, which is exactly why you return keys and read the item from DynamoDB rather than trusting the search document.
Practical playbook
- Write the access pattern inventory before any schema. Every pattern gets a name, a frequency, a latency target, and an owner who decides whether it matters.
- Have a human approve every partition key with an explicit cardinality estimate.
- Flag every Scan in generated code; route search access patterns to OpenSearch. Make this a lint rule, not a code review hope.
- Backfill with bulk put items using insert only or version guarded conditions, and keep CDC or dual writes for live traffic.
- Do not cut over until shadow reads show zero unexplained mismatches for a full business cycle.
A prompt template I use for step 1:
You are helping migrate a relational schema to DynamoDB.
Inputs: [slow query log], [ORM call sites], [API route list].
Produce a table of access patterns with: name, triggering API route,
source SQL, read or write, estimated requests per second, latency target,
and consistency requirement (strong or eventual).
Flag any pattern that is full text search, ad hoc filtering, or a
multi table join used only for reporting. Do not propose keys yet.
That last line matters. Keep the model listing before it starts designing.
Closing
The migration that lived in next half for three years now fits in a sprint or two, not because DynamoDB changed, but because the boring parts got cheap. What did not get cheap is deciding what the system should do. If you have run one of these with a copilot, I would like to hear where it saved you time and where it confidently led you into a hot partition.