What 1Z0-908 actually tests

The 1Z0-908: MySQL 8.0 Database Administrator exam is not a generic database test. It is aimed at people who administer MySQL Server 8.0 in real environments: installation, configuration, security, backups, replication, performance, and operational troubleshooting.

If your background is mostly SQL development, this exam will expose the gap quickly. You need to know how MySQL behaves as a service, not just how to write queries.

What you should expect:

The exam is built around MySQL 8.0 administration tasks, not application coding.
Oracle expects familiarity with:
- mysqld startup and configuration
- InnoDB architecture and operational behavior
- Accounts, roles, privileges, and authentication
- Binary logs, backups, restore, and point-in-time recovery
- Replication, including GTIDs and common topology management
- Performance Schema, EXPLAIN, indexing, optimizer behavior, and monitoring
- MySQL Shell, MySQL Router, and InnoDB Cluster concepts
Questions are typically objective-driven and practical. You may need to identify the right utility, syntax, or operational sequence.

This cert fits you if you are:

A junior or mid-level DBA working with MySQL 8.0
A Linux or platform admin who owns MySQL instances
A developer moving into database operations
An Oracle-certified candidate adding MySQL administration credibility

What makes this exam tricky is not the SQL. It is remembering the exact behavior of MySQL 8.0 features and the differences between similar tools. Example: when to use mysqldump versus MySQL Enterprise Backup versus binary-log-based recovery, or when statement-based vs row-based replication matters.

Treat the exam as a checklist of operational competence. If you cannot perform the topic in a lab, you probably do not know it well enough.

Build the server right: installation, configuration, and MySQL 8.0 internals

This domain is foundational. Oracle likes to test whether you understand how a MySQL server is deployed, configured, and managed at startup. Do not skim it because it feels basic.

Focus on these areas first:

Installation methods
- Oracle packages and platform packages
- Generic binary installation concepts
- Initializing the data directory with mysqld --initialize and --initialize-insecure
- Post-install steps such as setting the root password and securing access
Server startup and shutdown
- mysqld, mysqld_safe, service management
- Clean shutdown versus crash recovery implications
Configuration files and precedence
- my.cnf / my.ini
- Where options are read from
- Dynamic versus static system variables
- SET GLOBAL, SET PERSIST, and persistent configuration behavior in 8.0
Character sets and collations
- Server, database, table, and column defaults
- Why utf8mb4 matters
Data dictionary and metadata changes in MySQL 8.0
- The transactional data dictionary replacing older file-based metadata assumptions
Storage engines, especially InnoDB
- Default engine behavior
- Tablespaces, redo logs, undo, buffer pool basics
- Crash recovery fundamentals
Logging
- Error log
- General query log
- Slow query log
- Binary log purpose and configuration basics

You should be comfortable reading and explaining options like:

[mysqld]
port=3306
bind_address=0.0.0.0
server_id=101
log_bin=mysql-bin
binlog_format=ROW
gtid_mode=ON
enforce_gtid_consistency=ON
innodb_buffer_pool_size=2G
slow_query_log=ON
long_query_time=1

Know what each setting affects operationally.

Important MySQL 8.0 specifics to review:

Default authentication plugin behavior in 8.0 and compatibility considerations
Invisible indexes and generated columns at a high level
Atomic DDL concepts and what they improve
Instant ADD COLUMN and other online DDL improvements, at least conceptually

A common weakness here is memorizing commands without understanding consequences. Example: if you change a variable dynamically, does it survive restart? If you initialize insecurely, what security exposure does that create? If binary logging is off, what recovery options disappear?

Lab work for this domain:

Install MySQL 8.0 in a VM or container.
Initialize a fresh data directory.
Configure logs, buffer pool, and binary logging.
Verify settings with:
- SHOW VARIABLES
- SHOW ENGINE INNODB STATUS
- performance_schema views where relevant
Restart the server and confirm which settings persisted.

If you can explain the server lifecycle from installation to steady-state operation, you are in good shape for a large part of the exam.

Security and account administration: one of the highest-value scoring areas

This is a domain you can score well in if you study the details. It is also where candidates lose easy points because they rely on old MySQL habits.

You need to know how MySQL 8.0 handles authentication, authorization, password policy, and secure connectivity.

Study these topics carefully:

Account creation and management
- CREATE USER, ALTER USER, DROP USER
- Host-based account matching rules
- Account locking and password expiration
Privileges and roles
- Global, database, table, column, and routine privilege scopes
- GRANT, REVOKE
- Role creation, assignment, activation, default roles
Authentication plugins
- Especially caching_sha2_password and compatibility implications
- Basic awareness of alternatives such as mysql_native_password
Password management
- Password reuse restrictions
- Expiration policies
- Failed login tracking and account lock behavior where applicable
Secure connections
- SSL/TLS basics for client-server encryption
- REQUIRE SSL / X509 style account controls conceptually
Administrative security hygiene
- Principle of least privilege
- Avoiding broad grants like GRANT ALL ON *.*
- Separation of application accounts from DBA accounts
Auditing and security-related logging
- At least know what MySQL can log and where to inspect events relevant to security and access

Be able to read statements like these and know what they do:

CREATE USER 'appuser'@'10.%' IDENTIFIED BY 'StrongPass!23';
GRANT SELECT, INSERT, UPDATE, DELETE ON sales.* TO 'appuser'@'10.%';

CREATE ROLE 'reporting_readonly';
GRANT SELECT ON analytics.* TO 'reporting_readonly';
GRANT 'reporting_readonly' TO 'biuser'@'%';
SET DEFAULT ROLE 'reporting_readonly' TO 'biuser'@'%';

You should also understand the operational side:

Why a user can connect from one host but not another
Why a privilege appears granted but still does not work as expected
How role activation affects effective permissions
Why older clients may fail against newer authentication defaults

What Oracle tends to reward here is precision. Not broad concepts. Precision.

For example, know the difference between:

Authentication: proving identity
Authorization: what the account can do
Roles: privilege bundles assigned to accounts
SSL/TLS: encrypting traffic in transit

Hands-on tasks to do at least twice:

Create users with different host patterns.
Create and assign roles.
Enforce password change behavior.
Test a failed connection due to host mismatch or auth plugin mismatch.
Require secure transport for an account and verify connection behavior.

If your current job uses one shared root account for everything, this domain will feel more theoretical than it should. Fix that in your lab.

Protecting data: backup, restore, binary logs, and recovery scenarios

Backup and recovery is one of the most exam-relevant practical areas. Oracle expects you to know not only tools, but also which recovery method fits which failure.

Break this domain into four parts.

1. Logical backups

Know the role of:

mysqldump
mysqlpump

Understand:

Schema-only vs data-only backups
Consistent backups with transactional tables
The effect of options like --single-transaction
Restore workflow using the mysql client
Pros and cons of logical backups:
- Portable
- Human-readable
- Slower for large datasets
- More sensitive to restore-time schema and object ordering

2. Physical backups

You should know the purpose and advantages of MySQL Enterprise Backup if covered in your prep materials and official objectives. Even if you do not use it at work, understand where it fits:

Faster backup/restore for large InnoDB datasets
Hot backup capabilities
Incremental backup concepts
Better suited for enterprise-scale recovery windows

3. Binary logging and point-in-time recovery

This is a must-know area.

Study:

How to enable the binary log
Binary log format basics:
- ROW
- STATEMENT
- MIXED
Why row-based logging is generally preferred for replication correctness
mysqlbinlog usage for inspecting and replaying events
Point-in-time recovery (PITR) sequence:
1. Restore full backup
2. Apply binary logs up to a position or timestamp

Example workflow conceptually:

mysqlbinlog --stop-datetime="2026-03-20 10:15:00" mysql-bin.000123 | mysql -u root -p

Know the difference between:

Restoring an accidental table drop from a logical backup
Recovering to a point just before a destructive transaction
Recovering after an instance crash, where InnoDB crash recovery may already handle consistency at startup

4. Export/import and operational recovery details

Also review:

Importing dumps efficiently
Restoring users, routines, triggers, and events
Verifying backup integrity before you need it
Recovery testing, not just backup creation

This domain gets easier once you think in scenarios:

User deleted rows by mistake at 14:03 -> restore + PITR
Need to migrate one schema between environments -> logical dump/import
Large production instance with tight backup windows -> physical backup tooling
Server crashed unexpectedly -> understand InnoDB crash recovery and log usage

Lab this repeatedly:

Create a sample database.
Take a logical backup.
Enable binary logging.
Make several changes.
Simulate a destructive action.
Restore and recover to a precise point.

If you have never used mysqlbinlog, do not sit this exam yet.

Replication, HA, and clustered administration in MySQL 8.0

This is where the exam moves from single-server administration into production topology thinking. You need to know classic replication fundamentals and the newer MySQL 8.0 ecosystem around Group Replication, InnoDB Cluster, MySQL Shell, and MySQL Router.

Start with asynchronous replication basics:

Source/replica architecture
Binary log as replication source
Replica I/O and SQL threads, or their modern equivalents in process terms
Replication metadata and relay logs
Common replication filters and why they are risky
Replication lag and how to observe it

Then focus on modern best practice topics:

GTIDs
- What a GTID is
- Why GTID-based replication simplifies failover and provisioning
- Required settings such as gtid_mode=ON and enforce_gtid_consistency=ON
Binary log format
- Why ROW is commonly recommended in replicated environments
Replica configuration and provisioning
- Creating a replication user
- Setting server_id
- Initial data synchronization conceptually
- CHANGE REPLICATION SOURCE TO style modern syntax awareness
Replication monitoring and troubleshooting
- SHOW REPLICA STATUS
- Diagnosing lag, duplicate key errors, missing rows, and connectivity failures

Then study the MySQL 8.0 high-availability stack:

Group Replication
- Single-primary vs multi-primary concepts
- Automatic membership and fault detection at a high level
- Consistency and certification concepts
InnoDB Cluster
- Combination of Group Replication + MySQL Shell + MySQL Router
- Why it is Oracle's flagship HA architecture for MySQL 8
MySQL Shell
- AdminAPI basics
- Creating and managing an InnoDB Cluster conceptually
MySQL Router
- Application connection routing to the appropriate MySQL instance

You do not need to become a production architect for every edge case, but you must understand what each component does.

A simple mental map:

Replication = data movement from source to replica
GTID = globally unique transaction identity for easier coordination
Group Replication = fault-tolerant replicated group protocol
InnoDB Cluster = managed HA solution built on Group Replication
MySQL Router = client connection routing layer
MySQL Shell = administration interface for cluster tasks

If you can, practice a small topology:

1 source + 1 replica using GTID replication
Then read Oracle docs on converting that understanding into InnoDB Cluster concepts

Typical exam traps here:

Confusing asynchronous replication with Group Replication
Forgetting required server settings for GTIDs
Not understanding the role boundaries between MySQL Server, MySQL Shell, and MySQL Router
Treating failover as identical across classic replication and InnoDB Cluster

This domain is less about memorizing every command and more about recognizing the correct architecture and troubleshooting path.

Performance tuning, optimizer behavior, and operational monitoring

A MySQL DBA exam without performance would be incomplete. This section can be broad, but Oracle usually stays within practical administration boundaries: identify bottlenecks, read execution plans, understand indexing, and use MySQL's instrumentation.

Concentrate on these areas.

Query execution and optimizer basics

You should know how to use:

EXPLAIN
EXPLAIN ANALYZE at a conceptual level in 8.0

Read plans for:

Access type
Possible keys and chosen key
Rows examined estimates
Extra information such as filesort or temporary use

Indexing

Know when indexes help and when they do not.

Study:

Primary key and secondary index behavior in InnoDB
Composite index ordering
Covering indexes
Selectivity basics
Why functions on indexed columns can defeat efficient access
The effect of poor indexing on sorts, joins, and scans
Invisible indexes in MySQL 8.0 and why they are useful for testing index removal

InnoDB performance fundamentals

You do not need to become a storage-engine internals researcher, but you do need the admin view:

Buffer pool purpose and sizing importance
Redo logging and write durability tradeoffs conceptually
Checkpointing and flushing basics
Transaction isolation awareness
Locking and contention symptoms

Monitoring and instrumentation

Know the purpose of:

Performance Schema
sys schema
Status variables and process inspection
Slow query log

You should be able to identify which tool helps answer which question:

Slow statements? -> slow query log, Performance Schema
Wait events and contention? -> Performance Schema
Friendly summary views? -> sys schema
Current sessions and blockers? -> SHOW PROCESSLIST and related views

Common tuning workflow

The exam often rewards sane troubleshooting order:

Confirm the symptom.
Identify whether it is CPU, I/O, memory, locks, or bad execution plans.
Inspect slow queries and execution plans.
Check indexes and schema design.
Review server variables only after query and schema causes are considered.

This matters because many candidates jump straight to buffer sizes. Real MySQL performance problems are often query design and indexing first.

A small example worth practicing:

EXPLAIN SELECT customer_id, order_date
FROM orders
WHERE status = 'OPEN'
AND order_date >= '2026-01-01';

Ask yourself:

Is there a useful composite index?
Is the filter selective?
Is the optimizer scanning too much?
Would a covering index help?

Also review administrative maintenance topics tied to performance:

Optimizer statistics basics
Table analysis where relevant
Temporary tables and sort behavior conceptually
Resource contention during backups, imports, and DDL

This domain becomes manageable when you connect SQL behavior to server behavior. Do not study them separately.

A realistic prep plan based on your current MySQL experience

This exam is very passable if you already administer MySQL. It is not a two-week cram if your experience is mostly development.

Here is a realistic timeline.

If you already run MySQL in production: 3 to 4 weeks

Use this if you regularly handle installs, users, backups, and replication.

Week 1

Review official objectives line by line
Audit weak spots: Group Replication, MySQL Shell, security details, or PITR are common gaps
Build a fresh MySQL 8.0 lab

Week 2

Drill backups, restore, binary logs, and GTID replication
Recreate users, roles, SSL-related account settings
Review optimizer and Performance Schema basics

Week 3

Work through practice questions
For every miss, reproduce the topic in the lab
Read Oracle docs for exact syntax and behavior

Week 4

Final review of HA stack: InnoDB Cluster, Router, Shell
Memorize feature boundaries and operational sequences
Do one timed practice pass

If you are a developer or sysadmin with partial MySQL exposure: 6 to 8 weeks

Weeks 1-2

Installation, configuration, logs, startup, InnoDB basics
User management, roles, authentication plugins

Weeks 3-4

Logical backup/restore
Binary logs and PITR
Replication setup with GTIDs

Weeks 5-6

Performance Schema, EXPLAIN, indexing, slow query analysis
Group Replication, InnoDB Cluster, Router, Shell concepts

Weeks 7-8

Full review with practice questions
Focus only on missed objectives
Repeat labs until commands and workflows feel natural

If you are new to DBA work: 8 to 10 weeks

You can still do it, but you need repetition.

Spend the first two weeks just becoming comfortable with MySQL administration on Linux.
Do not touch advanced HA before you understand backups and privileges.
Expect security and replication syntax to take longer than you think.

The rule I give colleagues: 40% reading, 60% lab. This exam rewards operational memory.

Resources worth your time for oracle-1z0-908

Use resources that map directly to MySQL 8.0 administration. Skip generic SQL tutorials.

Official Oracle resources

Oracle University exam page for 1Z0-908
- Use it to confirm current objectives and exam logistics.
MySQL 8.0 Reference Manual
- This is the most important source.
- Prioritize chapters on:
  - Installing and upgrading MySQL
  - Server administration
  - Security
  - Backup and recovery
  - Replication
  - Group Replication
  - InnoDB storage engine
  - Optimization
  - Performance Schema
MySQL Shell User Guide
- Important for AdminAPI and InnoDB Cluster understanding.
MySQL Router documentation
- Read enough to understand topology role and routing purpose.

Books that match this exam well

MySQL 8 Administrator's Guide by Bhavin Desai, Anil Desai, and others
- Good practical coverage for admin workflows.
Learning MySQL by Seyed M.M. Tahaghoghi and Hugh E. Williams
- Better for foundations than advanced HA, but useful if you need grounding.
High Performance MySQL by Baron Schwartz, Peter Zaitsev, and Vadim Tkachenko
- Excellent for performance thinking. Use selectively for exam-relevant topics rather than reading cover to cover.

Hands-on environment

Best options:

A local Linux VM with MySQL 8.0 installed
Docker containers for quick rebuilds and replication labs
Three small instances if you want to experiment with Group Replication concepts

Practice and review

Use the 218 practice questions on Truekia as a review tool, not your primary learning source.
For every wrong answer:
- Find the exact feature in Oracle docs
- Reproduce it in your lab
- Write one sentence on why the correct answer is right and why the distractor is wrong

That last part matters. Oracle questions often include plausible wrong answers from older MySQL behavior or adjacent tools.

Last 48 hours and exam-day tactics for Oracle testing

Do not spend your final day reading all of MySQL again. Narrow it.

In the last 48 hours, review only these high-yield items:

Account management syntax and role behavior
Authentication plugins and secure connection basics
Binary log formats and PITR workflow
GTID requirements and replication status interpretation
Group Replication vs InnoDB Cluster vs Router vs Shell
EXPLAIN output basics, indexing rules, Performance Schema purpose
Dynamic vs persistent server configuration changes

A good final checklist is whether you can answer these without notes:

How do you persist a runtime config change in MySQL 8.0?
Which backup/recovery method supports point-in-time recovery?
Why is row-based replication preferred in many cases?
What does MySQL Router do that MySQL Shell does not?
What is the default authentication plugin in modern MySQL 8.0?
Which tool would you inspect for wait and statement instrumentation?

For Oracle exam delivery:

Read every option fully. Oracle-style questions often hinge on one exact term.
Watch for older syntax or outdated MySQL behavior hidden in distractors.
If two answers look right, prefer the one that matches MySQL 8.0 best practice, not legacy habit.
Do not overthink simple admin questions. If the question is about inspecting replication state, the answer is usually the direct replication status command, not a generalized monitoring tool.
Flag and return to long scenario questions. Secure the straightforward points first.

Final advice: if you cannot distinguish classic replication, Group Replication, and InnoDB Cluster cleanly, fix that before exam day. That confusion causes more avoidable misses than almost anything else on 1Z0-908.