Three weeks before a licensing renewal deadline, my team got told to get a 4TB Oracle database off Oracle entirely. Not "reduce core count," not "renegotiate," off. The old plan was a maintenance window: stop the app, export, import, pray, reopen. For a database that size, that's an outage measured in hours, and the business had already said no to hours. We ended up doing the cutover in under a minute using AWS DMS, and most of the work happened while the app kept running against Oracle like nothing was going on.

Here's how that actually works, where it bit us, and what I'd tell you to check before you trust it with your own migration.

What AWS DMS actually does here

AWS Database Migration Service (DMS) does two jobs in this scenario. First, a full load: it reads your existing Oracle tables and bulk-copies the data into Aurora PostgreSQL. Second, and this is the part that makes zero-downtime possible, it runs ongoing replication (CDC) by reading Oracle's redo logs through the Oracle LogMiner API (or the binary reader API for higher throughput) and applying those changes to the Aurora target in near real time. Your app keeps writing to Oracle the whole time. When the replication lag hits zero, you flip the app's connection string to Aurora, and you're done.

DMS does not do schema conversion. That's a separate tool, the AWS Schema Conversion Tool (SCT), which reads your Oracle schema (tables, views, indexes, and a lot of your PL/SQL) and generates the PostgreSQL equivalent. SCT converts most straightforward objects automatically, but it flags anything it can't handle (usually complex PL/SQL procedures with Oracle-specific packages or syntax) so you can rewrite those by hand before you touch DMS at all.

The actual how-to

Step 1: Prep the Oracle source for CDC.

Oracle has to be in archive log mode, and you need supplemental logging enabled so LogMiner can identify which row changed without relying on ROWID (which isn't stable across a heterogeneous migration):

ALTER DATABASE ADD SUPPLEMENTAL LOG DATA (PRIMARY KEY) COLUMNS; -- for any table without a primary key ALTER TABLE hr.employees ADD SUPPLEMENTAL LOG DATA (ALL) COLUMNS; 

If you're on RDS for Oracle, keep at least 24 hours of archive logs around so DMS has room to work if it falls behind:

EXEC rdsadmin.rdsadmin_util.set_configuration('archivelog retention hours', 24); 

Step 2: Convert the schema with SCT.

Point SCT at both databases, run the assessment report first, it tells you exactly which objects need manual rework before you commit to a timeline. Apply the converted DDL to your Aurora PostgreSQL target, but hold off on secondary indexes and foreign keys until after the full load, they only slow down bulk inserts.

Step 3: Create the DMS replication instance and endpoints, then the task.

{ "ReplicationTaskSettings": { "TargetMetadata": { "TargetSchema": "", "SupportLobs": true, "FullLobMode": false, "LobMaxSize": 64 }, "FullLoadSettings": { "TargetTablePrepMode": "DROP_AND_CREATE" } } } 

Set the migration type to "full load, ongoing replication" (full load + CDC). For LOB columns, use limited LOB mode with a max size set from your actual data (query it first, don't guess) instead of full LOB mode. Limited mode pre-allocates memory and is dramatically faster; full LOB mode moves LOBs one chunk at a time and is noticeably slower on anything but tiny objects.

-- find your real max LOB size before picking LobMaxSize SELECT dbms_lob.getlength(document_blob) AS lob_length FROM contracts ORDER BY lob_length DESC FETCH FIRST 10 ROWS ONLY; 

Step 4: Let full load finish, then rebuild secondary indexes and constraints on the target.

Step 5: Watch CDC catch up, then cut over.

Once CDCLatencySource and CDCLatencyTarget in CloudWatch both flatten near zero, stop application writes to Oracle for a few seconds, let the last transactions drain through CDC, verify counts match, and repoint your app to Aurora. That's your actual "downtime," and in our case it was under a minute.

Where this requires care

A few things burned us or nearly did, worth checking before you commit to a date:

  • Never enable triggers on the target during CDC. DMS is already replaying the changes those triggers would generate. We had an audit trigger fire twice on a handful of tables during a test run because someone re-enabled triggers "just to be safe." Don't.
  • CDC latency is not real-time, full stop. AWS is explicit that latency depends on workload, network, and replication instance sizing, and can stretch to minutes under load. Undersize the replication instance and your cutover window gets longer, not shorter.
  • Tables without primary keys are a real problem for CDC, not just a performance footnote. Add supplemental logging at the table level for them, and honestly, consider whether they need a real primary key before migration, not after.
  • LOB size assumptions will bite you. We initially set LobMaxSize based on a guess and silently truncated a handful of contract PDFs stored as BLOBs. Query the actual max size on the source first.
  • PostgreSQL doesn't support a custom CDC start timestamp. If you need to resume replication from a specific point, you're working with LSN-style checkpoint strings, not a UTC time, so plan your rollback/resume procedure around that limitation ahead of time, not during an incident.

My take

DMS with CDC is one of the few AWS services where the marketing claim ("minimal downtime migration") actually held up for us in production, but only because we treated the CDC prep work (supplemental logging, LOB sizing, index timing) as the real project and the cutover itself as the anticlimax. If you skip the prep and just click through the console defaults, you'll get a working migration that's slower and a cutover window that's longer than it needs to be. Budget your time on the boring parts.

Further reading