Training

Top 5 Objectives
Steve Hoberman
Instructor
Course outline

SQL and NoSQL Data Modeling Training

NoSQL data modeling methodology

Top 5 Objectives

Ideal for: Data modelers, architects, developers, and technical professionals seeking to bridge SQL and NoSQL modeling using one of the industry’s leading tools.

Master the art and science of data modeling across both SQL and NoSQL platforms — with the power of Hackolade Studio at your fingertips!

In this interactive 5-day virtual course, you’ll learn universal modeling principles and apply the Align, Refine, and Design methodology to create optimized models for relational databases and flexible NoSQL systems.

Using Hackolade Studio, you’ll gain real-world experience designing tables, documents, key-value stores, and graphs through guided exercises and case studies.

Along the way, you'll tackle advanced modeling challenges like scaling strategies, query optimization, schema evolution, and enterprise integration — all while building practical skills directly inside the Hackolade environment.

  1. Master Universal Data Modeling Principles: learn foundational modeling concepts that apply across both SQL and NoSQL systems, including how to define scope, focus, timer, filter, and mode to drive optimal database design.
  2. Develop SQL and NoSQL-Specific Modeling Skills: understand the key differences between relational (SQL) and non-relational (NoSQL) modeling, including normalization, key and index design, schema flexibility, and relationship representation.
  3. Apply the Align, Refine, and Design Methodology: practice a structured approach to data modeling — from gathering business requirements (Align), structuring data logically (Refine), to creating optimized physical models (Design) — tailored separately for SQL and NoSQL databases.
  4. Design Real-World SQL and NoSQL Data Models: build complete data models through practical case studies, developing relational schemas (tables, foreign keys, indexes) and NoSQL schemas (documents, key-value stores, graphs) for business scenarios.
  5. Solve Advanced SQL and NoSQL Modeling Challenges: address real-world complexities such as scaling, evolving schemas, query optimization, data integrity, and enterprise integration, applying best practices for both database types.

Prerequisite

This course assumes a basic understanding of fundamental data modeling concepts and terminology, such as entities, attributes, and relationships.

No prior experience with NoSQL databases is required.

Familiarity with SQL databases (such as writing simple queries or understanding basic table structures) is helpful but not mandatory.

Hackolade Studio will be introduced and used throughout the course; no previous experience with Hackolade is necessary.

Steve Hoberman, Instructor

Steve Hoberman

Steve Hoberman has trained more than 10,000 people in data modeling since 1992. Steve is known for his entertaining and interactive teaching style (watch out for flying candy!), and organizations around the globe have brought Steve in to teach his Data Modeling Master Class, which is recognized as the most comprehensive data modeling course in the industry.

Steve is the author of nine books on data modeling, including the bestsellers The Rosedata Stone and Data Modeling Made Simple. Steve is also the author of Blockchainopoly. One of Steve’s frequent data modeling consulting assignments is to review data models using his Data Model Scorecard® technique.

He is the founder of the Design Challenges group, creator of the Data Modeling Institute’s Data Modeling Certification exam, Conference Chair of the Data Modeling Zone conferences, director of Technics Publications, lecturer at Columbia University, and recipient of the Data Administration Management Association (DAMA) International Professional Achievement Award.

This Course Contains Five Modules

Module 1: Data Modeling Settings

Whether designing for SQL or NoSQL databases, several key factors determine the best data model for any given scenario. In this module, we will apply five settings that are universally applicable to both SQL and NoSQL databases:

  1. Scope: Defines the purpose of the data model, such as tactical (specific use cases) or strategic (enterprise-wide initiatives). For example, a tactical system might track transactions for a single business unit, while a strategic system would aggregate transaction data across multiple business units.
  2. Focus: Decides whether simplicity or flexibility is preferred in the model. A simple SQL model might focus on tightly defined tables and constraints, while a NoSQL model might prioritize flexibility to accommodate a variety of data types.
  3. Timer: Considers whether the model reflects current or future needs. An SQL model may start with normalized tables for structured data but could evolve to accommodate more flexible NoSQL structures, such as documents or key-value pairs, as data grows.
  4. Filter: Determines how to extract and query data. A business filter might focus on customer views in both SQL (e.g., JOINs across tables) and NoSQL (e.g., filtering customer documents), while an application filter might focus on specific data fields in either system (e.g., JSON objects in NoSQL or fields in SQL tables).
  5. Mode: Identifies the ideal approach for the specific initiative, whether it’s relational (SQL) or non-relational (NoSQL). This setting will help decide whether an OLTP system requires a relational model or an OLAP system is better suited for a dimensional approach with NoSQL.

Module 2: Data Modeling Components (SQL vs. NoSQL)

This module introduces key components for both SQL and NoSQL data modeling. While there are fundamental similarities, each has unique aspects:

  • Entities, Attributes, and Relationships:

    • SQL: Relational databases use tables to store data entities, with defined attributes (columns) and strict relationships (e.g., foreign keys, one-to-many).
    • NoSQL: Entities can be stored as documents (e.g., in MongoDB), key-value pairs (e.g., in Redis), or graphs (e.g., in Neo4j). Relationships in NoSQL databases are often modeled differently, such as through embedded documents or links in a graph.

  • Keys:

    • SQL: Primary and foreign keys enforce data integrity and relationships between tables.
    • NoSQL: Keys in NoSQL have multiple roles, such as partitioning and sorting, especially in systems like DynamoDB, where compound keys and secondary indexes are used.

  • Indexes:

    • SQL: SQL databases use traditional indexing (e.g., B-tree, hash) to speed up query execution, often relying on foreign key indexes for relationships.
    • NoSQL: NoSQL databases like Cassandra and MongoDB use specialized indexing (e.g., Global Secondary Indexes in DynamoDB, full-text search indexes in Elasticsearch).

We’ll explore these differences with hands-on examples, practicing both SQL table design and NoSQL schema design.



Module 3: Data Modeling Approach (Align, Refine, Design)

The Align, Refine, and Design approach applies to both SQL and NoSQL, but the techniques and focus will differ slightly depending on the database type.

  • Align:

    • SQL: In SQL, alignment means identifying the necessary business queries and ensuring the relational schema supports them efficiently, such as identifying tables, joins, and constraints.
    • NoSQL: Alignment in NoSQL involves understanding the queries and optimizing the document structure or key-value models to support them, keeping in mind the trade-offs between flexibility and performance.

  • Refine:

    • SQL: Refining an SQL model involves normalizing the data to remove redundancy and ensure consistency while optimizing for relational queries.
    • NoSQL: Refining NoSQL models involves considering the best ways to structure documents, relationships, or key-value pairs to support high-performance querying without the strict normalization requirements.

  • Design:

    • SQL: The design phase in SQL includes defining the physical schema (tables, indexes, constraints) and ensuring query performance is optimized with indexing and normalization.
    • NoSQL: For NoSQL, design focuses on creating schemas that are optimized for specific query patterns and scales, often leveraging denormalization to ensure fast access.

This module concludes with practical exercises where participants apply the Align, Refine, and Design approach to both SQL and NoSQL modeling.



Module 4: SQL and NoSQL Case Studies

In this module, we will explore case studies to apply the principles learned. Participants will design both SQL and NoSQL databases based on given requirements:

  • SQL Case Study: Design a relational database schema for a customer relationship management (CRM) system, including normalized tables, foreign keys, and indexes to support customer data, transactions, and interactions.
  • NoSQL Case Study: Design a NoSQL database for the same CRM system using MongoDB (document-based) or DynamoDB (key-value store), optimizing for flexible schema and high scalability.

Participants will deliver the following:

  • User stories and business terms model
  • Query alignment model for both SQL and NoSQL
  • Normalized logical data model (SQL) vs. document/key-value schema (NoSQL)
  • Physical schema for SQL databases and optimized NoSQL design for performance

Module 5: SQL and NoSQL Challenges

This module addresses advanced challenges common to both SQL and NoSQL modeling, while also focusing on the differences between the two:

  • Modeling within an enterprise architecture: How to choose between SQL and NoSQL when integrating with other systems (e.g., microservices, cloud data storage).
  • SQL vs. NoSQL for scalability: Addressing performance and scaling challenges in SQL databases with partitioning, sharding, and replication versus NoSQL approaches like horizontal scaling and eventual consistency.
  • Data Integrity and Transactions: In SQL, we'll focus on ACID compliance and relational constraints; in NoSQL, we'll discuss eventual consistency and managing data integrity without strong constraints.
  • Model evolution and maintenance: How to evolve SQL schemas with versioning and migration scripts, vs. evolving NoSQL models which tend to be more flexible but may require more careful schema management.
  • Advanced indexing and query optimization: Best practices for indexing in SQL (B-trees, full-text search) and NoSQL (secondary indexes, sparse indexing).

The module will include group discussions and problem-solving sessions to address real-world SQL and NoSQL challenges.

More information and schedule

Click here to ask a question or request a quote for Steve to teach this course to your team.