Non-Relational Databases: MongoDB & Cassandra

Program Duration: 1 Month (Intensive Track) | 2 Months (Standard Track)
Format: Blended (On-Campus & Online) with Recorded Lectures
Includes: Global Certification Prep + Live Projects + Real-World Database Design

Master the Databases Powering Modern Applications

The world runs on data—but not all data fits neatly into rows and columns. Social media feeds, IoT sensor streams, real-time analytics, and AI applications demand databases that are flexible, scalable, and lightning-fast .

This comprehensive course covers two of the world’s most widely adopted NoSQL databases: MongoDB (the leading document database) and Apache Cassandra (the powerhouse wide-column database) . In just one to two months, you’ll master both—understanding when to use each, how to design efficient data models, and how to deploy them at scale.

Whether you’re a backend developer, data engineer, or database administrator, this dual-database skillset makes you invaluable in today’s data-driven economy.

Why NoSQL? Why MongoDB & Cassandra?

• The Data Explosion: Traditional relational databases struggle with the volume, velocity, and variety of modern data. NoSQL databases are built for this new reality .

• Two Complementary Skills: MongoDB excels at developer agility and flexible schemas; Cassandra dominates high-throughput, always-available workloads . Mastering both makes you a complete database professional.

• Industry Adoption: MongoDB powers companies like Adobe, eBay, and Google; Cassandra runs at scale for Netflix, Twitter, and Apple .

• Cloud-Native Foundation: Both databases are the backbone of modern cloud applications and microservices architectures.

Part 1: MongoDB – The Document Database

MongoDB Fundamentals & Architecture

Introduction to NoSQL & MongoDB

• What is NoSQL? Why did it emerge? The four NoSQL database types 

• MongoDB history and philosophy: the “humongous” database

• JSON and BSON: how MongoDB stores data 

• MongoDB vs. RDBMS: terminology mapping and key differences 

MongoDB Architecture Deep Dive

• Database, collections, and documents: the hierarchical structure 

• BSON data types: strings, numbers, dates, arrays, embedded documents

• The _id field and primary keys

• Memory management and storage engine (WiredTiger)

• Journaling and crash recovery

Installation & Configuration

• Installing MongoDB on Windows and Linux

• Running MongoDB as a service

• MongoDB configuration file options

• MongoDB Compass: the GUI tool for visual exploration

CRUD Operations in MongoDB

Creating Data

• insertOne() and insertMany() operations

• Ordered vs. unordered bulk inserts

• Insert internals and write concerns 

Reading Data

• find() queries with query operators: $eq, $gt, $lt, $in, $and, $or 

• Querying embedded documents and arrays

• Projection: returning only the fields you need

• Cursors and pagination: limit(), skip(), sort() 

Updating Data

• updateOne(), updateMany(), replaceOne()

• Update operators: $set, $unset, $inc, $push, $pull 

• Upserts: update or insert in one operation

Deleting Data

• deleteOne() and deleteMany()

• Dropping collections and databases

Indexing & Aggregation

Indexing for Performance

• Single field indexes

• Compound indexes

• Multikey indexes (for arrays)

• Text indexes for search

• Geospatial indexes 

• Index creation strategies and performance monitoring

The Aggregation Framework

• Aggregation pipeline stages: $match, $group, $sort, $project

• Working with arrays: $unwind

• Joining collections with $lookup

• MapReduce (legacy) vs. aggregation framework

Replication & Sharding

Replication for High Availability

• Replica sets: primary and secondary nodes 

• Automatic failover and election process 

• Read preferences and write concerns

• Deploying and managing replica sets

Sharding for Horizontal Scaling

• When to shard: understanding the need

• Shard keys: choosing wisely 

• Config servers, mongos routers, and shard nodes

• Balancing chunks across shards

MongoDB Administration & Security

Backup & Recovery

• mongodump and mongorestore

• Filesystem snapshots

• Backup strategies for replica sets

Security

• Authentication mechanisms

• Role-based access control (RBAC)

• Network encryption with TLS/SSL

• Auditing

Monitoring & Troubleshooting

• mongostat and mongotop

• Database profiling

• Reading and analyzing logs

MongoDB Certification Pathways

Our curriculum prepares you for official MongoDB certifications :

Part 2: Apache Cassandra – The Wide-Column Database

Cassandra Fundamentals & Architecture

Introduction to Cassandra

• History: Born at Facebook, now an Apache top-level project 

• Cassandra’s place in the NoSQL ecosystem

• Key features: decentralized, elastic scalability, high availability, fault tolerance 

The Cassandra Architecture

• Peer-to-peer distributed design: no single point of failure 

• Gossip protocol for node communication 

• Partitioner: consistent hashing for data distribution

• Virtual nodes (vnodes) for balanced clusters 

• Snitches and replication strategies

CAP Theorem & Cassandra

• Cassandra as an AP database (Availability + Partition Tolerance) 

• Eventual consistency and tunable consistency levels 

Installation & Configuration

• Installing Cassandra on Linux

• cassandra.yaml: understanding key configuration parameters

• Starting and stopping the cluster

• nodetool: the essential administration utility

Cassandra Data Model

Cassandra Query Language (CQL)

• CQL syntax: similar to SQL but designed for Cassandra 

• Keyspaces: the top-level container

• Tables (column families): structure and options

Data Modeling in Cassandra

• Query-driven design: model around your queries, not your data 

• Primary key: partition key and clustering columns

• Partition key determines data distribution

• Clustering columns determine sort order within a partition

Design Patterns

• Wide rows vs. skinny rows

• Denormalization: embracing data duplication 

• Materialized views for query flexibility 

• Collections: sets, lists, maps

• User-defined types (UDTs)

Cassandra Architecture Deep Dive

Write Path

• Commit log: durability first 

• Memtables: in-memory writes

• SSTables: immutable on-disk storage 

• Compaction: merging SSTables for efficiency 

Read Path

• Reading from memtables and SSTables

• Bloom filters: quickly skipping unnecessary SSTables 

• Key cache and row cache

Anti-Entropy & Repair

• Read repair: fixing inconsistencies during reads

• Hinted handoff: handling temporary node failures 

• Merkle trees and anti-entropy repair 

• Tombstones and garbage collection

Data Operations with CQL

CRUD Operations

• INSERT statements and upsert behavior

• UPDATE operations (always upserts)

• DELETE and tombstone creation

• SELECT queries with filtering

Querying Best Practices

• Always include the partition key in WHERE clauses

• ALLOW FILTERING: when and when not to use

• Time-to-Live (TTL): expiring data automatically 

• Batch statements: atomic but not performance boosters

Cluster Operations & Management

Node Operations

• Adding and removing nodes

• Decommissioning nodes

• Rebuilding nodes

• Repairing nodes with nodetool repair

Monitoring & Performance Tuning

• Key metrics: read/write latency, compaction, pending tasks

• nodetool commands: status, info, cfstats, tablestats

• OpsCenter for visual management

• JVM tuning for Cassandra

Backup & Restore

• snapshots: backing up SSTables

• Incremental backups

• Restoring from snapshots

Integration & Advanced Topics

Cassandra Ecosystem

• Integration with Apache Spark for analytics 

• Integration with Apache Kafka for streaming

• Integration with Hadoop 

Cloud Cassandra

• Amazon Keyspaces (for Apache Cassandra) 

• Azure Managed Instance for Apache Cassandra

• DataStax Astra: serverless Cassandra 

Cassandra Certification Pathways