What the 1z0-062 exam actually feels like

This exam is mostly straight multiple-choice and multiple-response, and Oracle absolutely uses wording that forces you to know the exact administrative behavior, not just the concept. Expect around 77 questions in 120 minutes, which gives you roughly 90 seconds per question. That sounds manageable until you hit the items that embed SQL*Plus syntax, RMAN command options, startup states, listener behavior, or CDB/PDB rules in one stem.

The time sink is not calculation; it is Oracle’s habit of giving four answers that all sound plausible if you only know the topic at a high level. On this exam, the slowest questions are usually about:

instance startup/shutdown stages and what is available in each stage
RMAN backup/recovery command behavior
listener and naming resolution
multitenant architecture restrictions
memory management and initialization parameter precedence

A practical pacing method for this specific exam: move quickly through obvious architecture, terminology, and tool-identification questions, and bank time for the operational scenario items. If a question includes a command block with several clauses, that is usually where Oracle hides the trap. Mark it and return after clearing the easier factual items.

Also, Oracle exams commonly allow review before final submission, so use that to your advantage on syntax-heavy questions. I found it useful to leave a first-pass answer on every item, then revisit anything involving:

STARTUP NOMOUNT/MOUNT/OPEN
CREATE DATABASE
ALTER DATABASE ARCHIVELOG
RMAN retention policy, obsolete vs expired
listener registration and service naming
PDB open state and user/container context

Those are the questions where one keyword changes the answer.

Where the points really are: architecture, install, daily admin

If your study time is limited, do not spread it evenly. The exam leans heavily into core DBA operations for a single-instance Oracle Database 12c environment, with multitenant mixed into the architecture and administration questions. The broad buckets that showed up repeatedly were:

installation and database creation
Oracle architecture and memory/processes
managing database instances and storage basics
administering users, privileges, and security basics
backup/recovery with RMAN and flashback concepts
monitoring, advisors, and maintenance tools
network configuration and connectivity

What matters is not just knowing the tools, but knowing when Oracle wants you to use each one. Example: they like asking whether a task is done with DBCA, DBUA, NETCA, Enterprise Manager Database Express, SQL*Plus, or RMAN. If you blur those together, you’ll lose easy points.

For this exam, I would prioritize in this order:

12c architecture, instance startup, and background processes
CDB/PDB basics and administrative rules
RMAN backup/recovery and flash recovery area behavior
listener/service naming and Oracle Net configuration
installation tools, silent install concepts, and DBCA options
users/roles/profiles plus common admin SQL statements

The deceptively easy area is architecture. Oracle asks very plain-looking questions like which memory structure stores redo entries, or which process writes dirty buffers, but then mixes in AMM/ASMM, parameter files, or startup states. If you can’t link the components together operationally, the question becomes guesswork.

Installation and DB creation: Oracle loves option-level details

A lot of candidates underprepare installation because it feels basic. On 1z0-062, installation is not just “run OUI and click next.” Oracle asks about what gets created, which tools do what, prerequisite concepts, and post-install configuration.

Know the distinction between these tools cold:

OUI (Oracle Universal Installer) installs Oracle software.
DBCA creates and configures databases.
DBUA upgrades databases.
NETCA configures Oracle Net components.
OPatch applies interim patches.

Oracle also likes questions around starter database vs software-only install, administrative password setup, and what can be configured during DBCA. If you see a question asking how to create a database with templates, memory settings, storage options, and sample schemas, think DBCA.

Specific traps I saw in practice and in the exam style:

Confusing software installation with database creation.
Forgetting that spfile can be created from a pfile, and startup behavior differs depending on which exists.
Mixing up diagnostic destination, fast recovery area, and data file locations.
Assuming every parameter change is dynamic. Oracle loves to ask whether a restart is needed.

Be ready for questions on manual database creation too, even if DBCA is the practical default. That means understanding the role of:

parameter file
password file
control files
redo log groups
data files
CREATE DATABASE basics

If Oracle gives you a startup sequence scenario, remember the stages precisely:

NOMOUNT: instance starts, parameter file read, background processes start, no control file open.
MOUNT: control file opened, database associated, data files not yet opened.
OPEN: data files and redo logs opened for normal access.

That sequence appears in recovery and maintenance questions constantly. If a stem mentions renaming data files, enabling archivelog mode, or incomplete recovery, the right startup state matters.

Multitenant is tested at the admin level, not the marketing level

Oracle 12c means you need to be comfortable with container databases (CDB) and pluggable databases (PDB). The exam does not usually go deep into advanced multitenant licensing nuance, but it absolutely expects you to know the structure and what is managed where.

What to memorize functionally:

A CDB contains the root, seed, and one or more PDBs.
CDB$ROOT is the root container.
PDB$SEED is the template used to create new PDBs.
A PDB contains user/application data and can be plugged/unplugged.

The gotcha is user administration across containers. Oracle likes asking about:

common users versus local users
where a user is created
which privileges apply across containers
container context when issuing admin commands

If you see a username with the C## style naming, think common user in a CDB. If the question is about a user existing only inside one pluggable database, that is a local user. Oracle often makes the wrong answers sound valid by changing only the container scope.

Another common trap: open state persistence. A PDB can be opened and closed independently, and Oracle may ask what survives an instance restart. If you haven’t practiced the commands, these questions feel abstract. Spend time with:

switching session container
opening/closing a PDB
saving PDB open state
querying views that expose container information

Also know that some dictionary views have CDB_, DBA_, and V$ variants with different scope. Oracle may not ask for obscure view names, but it does ask enough architecture/admin questions that you should know whether information is at the instance, database, or container level.

This is one of those domains where reading is not enough. If you can, actually create or at least simulate PDB administration tasks in a lab. The exam likes very ordinary operational scenarios, such as creating a user in the wrong container, or trying to manage a PDB from the wrong context.

RMAN, flashback, and recovery: the section that punishes fuzzy knowledge

This is the area where Oracle is least forgiving. You need to know what RMAN does by default, how it treats the repository, and how backup/recovery choices interact with ARCHIVELOG mode, the fast recovery area (FRA), and control file metadata.

The biggest trap set is around the words obsolete and expired.

Obsolete means a backup is no longer needed according to the retention policy.
Expired means RMAN expected the backup to exist physically but could not find it during a crosscheck.

Oracle loves to test that distinction because people memorize commands without understanding repository state. Tie the commands to the meanings:

CROSSCHECK updates repository status based on physical existence.
DELETE EXPIRED removes repository records for missing files.
DELETE OBSOLETE removes backups no longer needed by policy.

Another repeated theme is what recovery options are possible in NOARCHIVELOG versus ARCHIVELOG mode. Be blunt with yourself here: if you cannot explain why media recovery options are limited without archived redo logs, you are not ready for this section.

Specific things worth drilling:

full database backup versus image copy concepts
backup sets versus copies
control file autobackup purpose
archived redo log handling
point-in-time recovery basics
complete vs incomplete recovery
flashback database prerequisites at a high level
FRA space pressure behavior and file management implications

Oracle also likes “which command sequence is valid” style questions. Practice reading RMAN syntax in blocks, not just individual commands. A question may present four options that differ only in one clause order or one object type.

One more gotcha: do not mix up instance recovery and media recovery.

Instance recovery happens automatically after a crash using online redo logs.
Media recovery is needed when restoring damaged or lost files, often using backups and archived redo.

That difference shows up in architecture and recovery questions alike. If the stem says the database terminated unexpectedly but files are intact, think instance recovery, not restore-and-recover.

Networking, listeners, and naming methods: easy points if you know Oracle’s exact terms

This exam includes enough Oracle Net that you should treat it as a scoring opportunity, not a side topic. The questions are usually not deeply technical, but they are precise. Oracle expects you to distinguish among:

listener
service name
SID
tnsnames.ora
listener.ora
Easy Connect naming
dynamic service registration

The trap here is that many DBAs work in environments where these files are already configured, so they know the outcome but not the exact mechanism. Oracle asks about the mechanism.

Key reminders:

The listener accepts client connection requests.
Clients often resolve connect descriptors through tnsnames.ora or Easy Connect.
Database instances can register services dynamically with the listener.
A service name is not the same thing as a SID, even though people casually treat them as interchangeable.

Questions often describe a connection problem and ask what file, utility, or parameter is relevant. If the issue is client-side naming resolution, think tnsnames.ora. If it is listener process configuration, think listener.ora. If the question is about testing connectivity, remember the common tools Oracle expects you to recognize.

I also saw several prep questions where the wrong answer exploited confusion between database name, instance name, and service name. Clean that up before exam day. Oracle uses those terms deliberately.

For quick revision, make sure you can explain in one sentence each:

what the listener does
where a net service name is defined
what dynamic registration means
when Easy Connect is sufficient
why a service name is preferred in many client connections

Users, privileges, memory, and background processes: the 'simple' section with hidden traps

This part looks beginner-friendly until Oracle starts mixing user administration with initialization parameters or process responsibilities. Don’t just memorize lists; connect them to administration tasks.

For users and privileges, focus on:

system privileges vs object privileges
roles vs direct grants
profiles and password policy basics
administrative privileges such as SYSDBA at a conceptual level
account locking, password expiration, and default tablespace concepts

Oracle likes to ask which privilege allows a task rather than how to type the command. If multiple answers look possible, check whether the task is database-wide administrative or object-specific.

For memory management, know the difference between:

SGA and PGA
major SGA components such as database buffer cache, shared pool, redo log buffer
automatic memory management versus automatic shared memory management

Typical trap: Oracle describes a symptom or parameter and expects you to identify whether it affects total memory, SGA-only tuning, or process-private memory. If the answer choices include both AMM and ASMM, read the parameter names carefully.

For background processes, know the jobs of at least the core ones:

DBWn writes dirty buffers to data files
LGWR writes redo entries to online redo logs
CKPT signals checkpoints and updates headers/checkpoint info
SMON handles instance recovery and cleanup tasks
PMON cleans up failed user processes and frees resources
ARCn archives redo logs in ARCHIVELOG mode

Oracle often makes this harder by describing the action instead of naming the process. Example: if the question says “writes committed changes sequentially for recovery purposes,” think redo and LGWR, not DBWn.

This section is where flashcard-style memorization actually helps, because the exam uses a lot of one-line operational descriptions.

What to do in the final week if you have 250 practice questions

With 250 practice questions available, the best use of the final week is not another full read of the syllabus. Use the question bank to identify which Oracle behaviors you still confuse under pressure.

Split your final review into these buckets:

Day 1-2: installation tools, startup states, parameter files, architecture
Day 3: CDB/PDB administration, common vs local users, container context
Day 4: RMAN, FRA, ARCHIVELOG/NOARCHIVELOG, obsolete vs expired
Day 5: networking, listener/service naming, users/roles/profiles
Day 6: weak-area retest only
Day 7: command review and glossary cleanup

When reviewing misses, classify them, don’t just reread explanations. For this exam, most wrong answers fall into one of these categories:

confused two Oracle tools
knew the concept but not the exact startup/recovery stage
mixed up CDB root and PDB scope
forgot RMAN terminology
confused listener/service/SID naming
guessed on process or memory component roles

That classification tells you what to fix. If 30% of your misses are stage-related, spend an hour drilling only NOMOUNT/MOUNT/OPEN, archivelog enablement steps, and recovery state requirements.

A very effective last-week exercise for 1z0-062 is making a one-page sheet with only contrasts. Examples:

OUI vs DBCA vs DBUA vs NETCA
pfile vs spfile
NOMOUNT vs MOUNT vs OPEN
ARCHIVELOG vs NOARCHIVELOG
obsolete vs expired
service name vs SID
common user vs local user
instance recovery vs media recovery

Those contrasts map directly to how Oracle writes distractors.

Oracle exam interface habits that matter on this test

Because this exam includes many wording-sensitive items, use the review screen strategically. The Oracle testing interface is straightforward, but on 1z0-062 the main risk is committing too early on a half-remembered command behavior.

A few exam-specific habits helped:

Mark any question containing two or more command clauses or startup/recovery state wording.
On review, reread only the verbs in the stem: create, configure, recover, open, mount, register, archive, grant. Oracle often hides the distinction there.
If a question asks for two answers, verify each selected option independently. On Oracle exams, one option is often clearly right and the second is a near-match from a related feature.

Do not spend too long trying to reconstruct exact syntax from memory if the exam is really testing behavior. Example: if the question is fundamentally about whether a PDB task must be done in the root or inside the PDB, focus on container scope first. Likewise, for RMAN questions, anchor yourself on repository meaning and recovery objective before worrying about command cosmetics.

The final pass should focus on flagged items from these themes only:

RMAN terminology and command effect
startup states and recovery prerequisites
multitenant scope and user type
listener/service naming distinctions
background process responsibilities

That is where the exam hides most of its avoidable losses.