NoSQL database
A NoSQL database is a database system organized primarily around nonrelational data models rather than the traditional relational table model.
Building Web APIs with ASP.NET Core
NoSQL is a class of nonrelational database systems that use flexible data models such as documents, key-value collections, graphs, or wide columns.
- How it is used
- Frames NoSQL as an alternative database model for selecting storage behind a web API.
- How deep it goes
- Defines document storage and relationship differences, but stops short of detailed product-specific behavior.
- Examples
- Uses MyBGList board-game records, CSV imports, document collections, and paired SQL and NoSQL schema diagrams.
- What you can do after
- Evaluate SQL and NoSQL choices against dataset size, schema consistency, scaling needs, caching, paging, and framework support.
Read how Building Web APIs with ASP.NET Core explains NoSQL database →
ScyllaDB in Action
A NoSQL database is a non-relational database system that uses data models other than the traditional relational table model.
- How it is used
- Positions non-relational storage as a scalable, distributed alternative to relational databases.
- How deep it goes
- Explains the definition, wide-column storage, horizontal scaling, availability, consistency, and BASE-versus-ACID trade-offs.
- Examples
- Uses ScyllaDB storage comparisons and ONE, QUORUM, and ALL consistency levels as concrete examples.
- What you can do after
- Evaluate distributed database choices by comparing scalability, fault tolerance, availability, and consistency requirements.
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
A NoSQL database is a nonrelational database designed for data models and scaling approaches that do not depend on the traditional relational table model.
- How it is used
- Uses nonrelational data models for scalable web applications and exposes managed database capabilities through an API.
- How deep it goes
- Defines four NoSQL types and explains DynamoDB architecture, scaling, application fit, administration, capacity, and backups.
- Examples
- Uses a web application querying DynamoDB, client-side error tracking, AWS service diagrams, and Free Tier storage limits.
- What you can do after
- Apply DynamoDB in an application, configure access and capacity, monitor usage, and create backups for recovery.
The Cloud at Your Service: The when, how, and why of enterprise cloud computing
NoSQL refers to a class of database systems that use data models other than, or in addition to, the relational model.
- How it is used
- Frames NoSQL as a storage choice for cloud applications facing large workloads.
- How deep it goes
- Explains item-oriented storage and its scaling trade-offs through comparison with relational joins and referential integrity.
- Examples
- Compares car makes, models, and colors stored in relational tables with the same data in item-oriented storage.
- What you can do after
- Evaluate NoSQL storage trade-offs involving scaling, duplicated data, joins, and application-managed integrity.
Think Like a CTO
A NoSQL database stores data without requiring the fixed tabular structure and schema constraints typical of relational databases.
- How it is used
- Positions NoSQL as a storage option when data does not fit the uniform structure of relational tables.
- How deep it goes
- Defines documents and collections and contrasts their structure with tables, without detailing database operations or implementation.
- Examples
- Illustrates a collection whose documents can differ radically and need no placeholders for missing data.
- What you can do after
- Evaluate/understand whether varying document structures make NoSQL worth considering instead of relational tables.
Java Persistence with Spring Data and Hibernate epub
A NoSQL database is a nonrelational database system designed around data models and access patterns other than the traditional relational table model.
- How it is used
- Frames NoSQL databases as flexible-schema persistence options and demonstrates accessing them through MongoDB tools or portable persistence APIs.
- How deep it goes
- Defines major NoSQL data models and demonstrates JPA transactions, entity lookup, JPQL queries, and resulting MongoDB collections.
- Examples
- Uses MongoDB documents, Compass filters, JPA entity tests, MongoDB collections, and JPQL queries over users, items, and bids.
- What you can do after
- Apply NoSQL persistence through MongoDB Compass, JPA, JPQL, and Hibernate OGM while preserving transaction boundaries.
Read how Java Persistence with Spring Data and Hibernate epub explains NoSQL database →
Grokking Software Architecture
A database system that does not primarily use the relational table-and-SQL model and commonly supports a nonrelational data model.
- How it is used
- Frames NoSQL as a specialized storage option to evaluate alongside SQL and vector databases.
- How deep it goes
- Sets up tradeoff-based comparison and applies it to storage choices, without detailing NoSQL internals.
- Examples
- Uses a read-heavy variable-structure catalog and contrasts session data with a financial ledger.
- What you can do after
- Evaluate database fit by weighing workload, variable structure, CPU pressure, and data-integrity needs.
Read how Grokking Software Architecture explains NoSQL database →
Microsoft Azure in Action
A NoSQL database is a nonrelational database designed to store and retrieve data using flexible structures rather than a fixed relational schema.
- How it is used
- Supports globally distributed product catalogs, customer traffic, real-time analytics, and rapidly changing application features.
- How deep it goes
- Explains schema flexibility, denormalization, embedded documents, and design trade-offs, then points toward partitioning without detailing its algorithms.
- Examples
- Uses an Alpaca-Ma-Bags product catalog, variable product records, embedded supplier details, and a complete product document.
- What you can do after
- Evaluate and design flexible document models while weighing read performance, scalability, consistency, and cost.
Read how Microsoft Azure in Action explains NoSQL database →
Fast by Default
A NoSQL database is a nonrelational database designed around data models and access patterns that do not require traditional relational tables and joins.
- How it is used
- Frames database selection around application access patterns and workload-specific performance.
- How deep it goes
- Distinguishes document, key-value, and wide-column models with concrete tradeoffs, but stops short of implementation guidance.
- Examples
- Uses blog posts with comments, session data, caching, and key-based lookups to contrast database models.
- What you can do after
- Evaluate NoSQL models against an application's reads, writes, query requirements, and scaling needs.
Troubleshooting Java: Read, debug, and optimize JVM applications
A database that uses a nonrelational data model rather than the relational model.
- How it is used
- Uses nonrelational databases to persist logs or provide an alternative application persistence technology.
- How deep it goes
- Explains log-storage tradeoffs and demonstrates profiled MongoDB operations without detailing NoSQL data models.
- Examples
- Uses log storage and a MongoDB product app with monitored write and read operations.
- What you can do after
- Diagnose MongoDB interactions by inspecting operation counts, execution times, and stack traces in JProfiler.
Read how Troubleshooting Java: Read, debug, and optimize JVM applications explains NoSQL database →
Building Distributed Applications that Work
A non-relational database system that stores and accesses data using models other than relational tables and does not rely primarily on SQL.
- How it is used
- Guides storage selection by matching non-relational models to workload needs and situates NoSQL among Aspire storage integrations.
- How deep it goes
- Defines NoSQL by its non-reliance on relational tables or SQL, distinguishes four models and their workloads, and stops short of setup details.
- Examples
- Illustrates four models with MongoDB, Redis, Neo4j, and Cassandra, and associates them with cache, warehousing, social, and logistics workloads.
- What you can do after
- Evaluate storage choices by matching key-value, column-family, graph, and document models to their stated workload strengths.
Read how Building Distributed Applications that Work explains NoSQL database →
Also covered in
- Cloud Observability in Action
- 100 SQL Server Mistakes and How to Avoid Them
- PostgreSQL Mistakes and How to Avoid Them
- The Quick Python Book, Fourth Edition
- Elasticsearch in Action, Second Edition
- Vibe EngineeringIn early access (MEAP)
- Troubleshooting Java, Second Edition
- The Well-Grounded Python Developer: How the pros use Python and Flask
- Spring in Action, Sixth Edition
- Grokking Web Application Security
- Google Anthos in Action
What to know first
- SQLSQL is a standardized declarative language for defining, querying, and manipulating data in relational database systems.
- ACIDACID is the set of database transaction properties—atomicity, consistency, isolation, and durability—that characterize reliable transactional behavior.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- scalabilityScalability is the ability of a system or process to accommodate growth in workload, size, or demand while maintaining acceptable operation.
Related concepts
- MongoDBincludes · MongoDB is a document-oriented database management system that stores data as BSON documents, typically organized into collections.
- Cosmos DBincludes · Azure Cosmos DB is Microsoft's globally distributed, multimodel cloud database service, supporting multiple data models and APIs.
- SQLcontrasts with · SQL is a standardized declarative language for defining, querying, and manipulating data in relational database systems.
- consistencycontrasts with · Consistency is the degree to which related data, behavior, or results agree with one another and conform to applicable rules or expectations.
- persistenceuses · Data persistence is the retention of data in storage so it remains available beyond the process or computation that created or changed it.
Questions about NoSQL database
What is NoSQL database?
A NoSQL database is a database system organized primarily around nonrelational data models rather than the traditional relational table model.
Which Manning books explain NoSQL database?
Building Web APIs with ASP.NET Core, ScyllaDB in Action, Amazon Web Services in Action, Third Edition: An in-depth guide to AWS, The Cloud at Your Service: The when, how, and why of enterprise cloud computing, Think Like a CTO, Java Persistence with Spring Data and Hibernate epub, Grokking Software Architecture, Microsoft Azure in Action and 3 more.
What should I know before learning NoSQL database?
Manning books that teach NoSQL database usually introduce SQL, ACID, JSON and scalability first.
What is the difference between NoSQL database and SQL?
A NoSQL database is a database system organized primarily around nonrelational data models rather than the traditional relational table model. SQL is a standardized declarative language for defining, querying, and manipulating data in relational database systems.
What kinds of NoSQL database are there?
Kinds of NoSQL database include MongoDB, Cosmos DB and Neo4j.
What is NoSQL database also called?
NoSQL database is also called Nonrelational databases, non-relational database or NoSQL systems.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.










