Task Statement 3.3: Determine high-performing database solutions.

📘AWS Certified Solutions Architect – (SAA-C03)

1. What is a Database Type?

A database type defines how data is stored, structured, and accessed.

There are three major categories you must know:

1. Relational Databases (SQL)

2. Non-Relational Databases (NoSQL)

3. In-Memory Databases

4. Serverless Databases (deployment model, not a data model)

2. Relational Databases (SQL)

What is it?

A relational database stores data in:

Tables (rows and columns)
Fixed schema (structure must be defined in advance)
Relationships between tables using keys

Key Features

Uses SQL (Structured Query Language)
Strong consistency (ACID compliance)
Supports complex queries and joins
Structured data only

AWS Services

Amazon RDS
Amazon Aurora

When to Use

Use relational databases when:

Data has a clear structure
You need relationships between data
You need transactions (ACID)

IT-Based Example

User authentication system (users, roles, permissions stored in tables)
Financial transaction systems (strict consistency required)

Amazon RDS (Relational Database Service)

What it is

Managed relational database service

Supported Engines

MySQL
PostgreSQL
MariaDB
Oracle
SQL Server

Key Benefits

Automated backups
Patching
Monitoring
Multi-AZ for high availability

Amazon Aurora

What it is

A high-performance relational database compatible with MySQL and PostgreSQL

Key Features

Up to 5x faster than MySQL
Storage auto-scales
Built-in replication (6 copies across AZs)
Serverless option available

3. Non-Relational Databases (NoSQL)

What is it?

Non-relational databases:

Do NOT use tables
Have flexible schema
Designed for scalability and performance

Types of NoSQL Models

You should know these:

Key-Value
Document
Wide-column
Graph (less common in AWS exam)

Key Features

Schema-less (flexible)
High scalability
High performance
Eventually consistent (sometimes)

AWS Services

Amazon DynamoDB
Amazon DocumentDB
Amazon Keyspaces (for Apache Cassandra)

When to Use

Use NoSQL when:

Data structure changes frequently
Need massive scalability
High read/write throughput
Low latency required

Amazon DynamoDB

What it is

Fully managed NoSQL key-value and document database

Key Features

Serverless (no infrastructure management)
Millisecond latency
Auto scaling
Built-in caching option (DAX)

Use Cases (IT-focused)

Session storage for applications
Real-time user activity tracking
High-traffic APIs

Amazon DocumentDB

What it is

Document database (MongoDB-compatible)

Key Features

JSON-like document storage
Flexible schema
Scales easily

4. In-Memory Databases

What is it?

Stores data in RAM instead of disk

Key Features

Extremely fast (microsecond latency)
Used for caching and real-time processing

AWS Services

Amazon ElastiCache
- Redis
- Memcached

When to Use

Use in-memory databases when:

Ultra-fast performance is required
Data is accessed very frequently
Temporary or cached data

Amazon ElastiCache

Key Features

Reduces load on primary database
Improves application performance
Supports Redis and Memcached

IT Use Cases

Caching database queries
Session management
Real-time leaderboards or counters

5. Serverless Databases

What is it?

Serverless means:

No server management
Automatic scaling
Pay only for usage

AWS Services

Amazon Aurora Serverless
Amazon DynamoDB (fully serverless)

Key Features

Auto scaling (up/down)
No capacity planning
Cost-efficient for variable workloads

When to Use

Use serverless databases when:

Workload is unpredictable
Traffic fluctuates
You want minimal operational effort

Aurora Serverless

Automatically starts/stops
Scales based on demand
Ideal for intermittent workloads

6. Comparison: Relational vs Non-Relational

Feature	Relational	Non-Relational
Structure	Fixed schema	Flexible schema
Data Format	Tables	JSON / key-value
Scalability	Vertical (mostly)	Horizontal
Query	SQL	API-based
Consistency	Strong	Eventual (mostly)
Use Case	Structured data	High-scale apps

7. Key Exam Decision Points

You must be able to quickly choose the right database:

Choose Relational (RDS / Aurora) if:

Data has relationships
Requires ACID transactions
Complex queries needed

Choose DynamoDB if:

Need massive scale
Low latency (single-digit ms)
Serverless required

Choose ElastiCache if:

Need caching
Want faster reads
Reduce database load

Choose Aurora if:

Need high performance + relational
Need better scalability than RDS

Choose Serverless if:

Unpredictable traffic
Want automatic scaling
Want minimal management

8. Important Exam Tips

DynamoDB = serverless + NoSQL + massive scale
Aurora = high-performance relational
ElastiCache = caching (not primary database)
RDS = traditional relational workloads
Serverless = no infrastructure management

9. Common Exam Traps

Be careful of:

Choosing RDS when scaling is very high → DynamoDB is better
Using ElastiCache as primary DB → it’s only for caching
Ignoring serverless when workload is unpredictable
Choosing relational when schema is flexible → use NoSQL

Final Summary

Relational (RDS/Aurora): structured, consistent, transactional
NoSQL (DynamoDB): scalable, flexible, high performance
In-Memory (ElastiCache): ultra-fast caching
Serverless (Aurora Serverless/DynamoDB): automatic scaling, no management