Three quick calculators I use as a working Oracle DBA: size your UNDO tablespace from a retention target, get a starting point for TEMP, and plan RMAN backup / Fast Recovery Area storage from your database size, change rate and recovery window. Everything runs locally in your browser โ nothing is sent anywhere.
Oracle's own guidance sizes undo from three things: how long you need to keep undo (UNDO_RETENTION), how fast the database generates undo (undo blocks per second), and the block size:
UNDO size = UNDO_RETENTION × undo_blocks_per_sec × DB_BLOCK_SIZE
To get your real undo rate, query V$UNDOSTAT (each row is a ~10-minute snapshot):
SELECT MAX(undoblks / ((end_time - begin_time) * 86400)) AS peak_ups
FROM v$undostat;
Feed that peak into the calculator, keep a safety buffer, and if you rely on Flashback Query you may want RETENTION GUARANTEE on the tablespace โ just be aware it will let transactions fail with ORA-30036 rather than overwrite unexpired undo, so it needs headroom. If you regularly hit ORA-01555 "snapshot too old", either the retention or the tablespace is too small for your longest-running queries. (I wrote a full walkthrough on that in the undo, redo & ORA-01555 guide.)
TEMP is harder to pin to a single formula because it depends entirely on your workload โ big sorts, hash joins, global temporary tables and index rebuilds all draw from it. A practical planning approach is to multiply the largest work area a heavy query uses by how many such queries run at once, then add headroom:
TEMP ≈ max_work_area × concurrent_heavy_sessions × (1 + headroom)
Treat the result as a floor, not gospel. Watch V$TEMPSEG_USAGE and V$SORT_USAGE during your real peak (month-end reports, big batch jobs, index maintenance), and configure TEMP with autoextend plus a firm MAXSIZE so a single runaway sort cannot fill the disk.
Your Fast Recovery Area has to hold enough to satisfy your recovery window โ the number of days back you must be able to restore to. The calculator adds up three pieces:
Set DB_RECOVERY_FILE_DEST_SIZE comfortably above the estimate, keep a RECOVERY WINDOW OF n DAYS retention policy, and let DELETE OBSOLETE reclaim space. Undersizing the FRA is a classic 3 a.m. outage โ archiver stops, and the database hangs. For the full backup-and-recovery playbook, see my RMAN backup & recovery guide.
Multiply your undo retention target (in seconds) by the peak undo blocks generated per second and by the database block size: UNDO size = UNDO_RETENTION ร undo_blocks_per_sec ร DB_BLOCK_SIZE. Get the undo rate from V$UNDOSTAT, add a safety buffer of 15โ30%, and set UNDO_RETENTION to your target. This calculator does that math for you.
Set UNDO_RETENTION at least as long as your longest-running query or the furthest-back Flashback Query you need. 900 seconds (15 minutes) is a common starting point for OLTP, but reporting or batch systems with long queries often need much more. If you see ORA-01555 "snapshot too old", your retention or undo tablespace is too small for your query duration.
There is no single formula โ TEMP depends on concurrent sorts, hash joins and global temporary tables. A practical starting point is the largest work area a heavy query uses multiplied by the number of such queries running at peak, plus headroom. Then validate against V$TEMPSEG_USAGE and V$SORT_USAGE under real load and use autoextend with a MAXSIZE.
Add up the full backups you must keep for your recovery window, the incremental backups (roughly daily changed data), and the archived redo generated across the window โ each reduced by compression. Set DB_RECOVERY_FILE_DEST_SIZE above that total and monitor V$RECOVERY_FILE_DEST. The RMAN tab of this calculator estimates all three for you.
No. All three calculators run entirely in your browser with plain JavaScript. Nothing you type is uploaded, logged or stored โ it is safe to use with production planning figures.
They are informed planning estimates, not guarantees. Real undo, temp and backup sizes vary with block density, deletes, redo volume and workload spikes. Use the results as a defensible starting point, then confirm against your own database's dynamic performance views before you commit storage.