Database
A database is an organized persistent data store, typically managed by software, that supports storing, retrieving, and modifying data.
A Pythonic Adventure: From Python basics to a working web app
A database is a program or organized persistent system that stores data and performs operations such as searching and summarizing it.
- How it is used
- Stores coffee-shop orders so a Flask application can save submissions and later display an order list.
- How deep it goes
- Works through SQLite table creation, INSERT, commit, SELECT, fetched rows, and template display without detailing database internals.
- Examples
- Uses coffee-shop order forms, an orders table, save_order(), get_orders(), and an HTML table listing names and menu choices.
- What you can do after
- Apply it via SQLite and Flask to create a table, save submitted orders, retrieve rows, and render an order list.
Read how A Pythonic Adventure: From Python basics to a working web app explains database →
Coding with AI
A database is a system that stores organized information and retrieves records matching explicit queries.
- How it is used
- Uses databases as application data stores and contrasts stored-record retrieval with probabilistic language-model generation.
- How deep it goes
- Walks through CSV import and key configuration, then leaves application connection functionality for a later step.
- Examples
- Uses a multiple-choice radio-license question pool and a task-tracking application schema.
- What you can do after
- Operate/configure a SQLite database by importing question data, setting an ID key, and browsing the resulting table.
Data Analysis with LLMs
A structured collection of data organized for storage, retrieval, and management by computer software.
- How it is used
- Stores tabular data for efficient analysis while a language model translates plain-language questions into SQL.
- How deep it goes
- Defines relational tables and walks through SQLite setup and CSV import, without explaining database storage internals.
- Examples
- Uses a video-game table and SQLite file, plus a query for the highest-selling game in 2016.
- What you can do after
- Build it from scratch in SQLite by creating a table, importing CSV data, and checking its row count.
Build Financial Software with Generative AI (From Scratch)
A database is an organized system for storing and retrieving structured data across application instances.
- How it is used
- Supports persistent, queryable ACH data for a dashboard and business intelligence analytics.
- How deep it goes
- Works through relational design, field types, storage integration, integrity, and testing, while leaving broader backend topics for further investigation.
- Examples
- Uses an ACH upload schema with file records, headers, entries, and typed amount fields.
- What you can do after
- Apply it via PostgreSQL to store unaltered and parsed ACH records for querying.
Read how Build Financial Software with Generative AI (From Scratch) explains database →
Apache Kafka in Action
A database is a software system that durably stores, organizes, and supports querying of data.
- How it is used
- Positions relational databases as stores for service-specific current state, contrasted with Kafka’s role in exchanging event history.
- How deep it goes
- Explains queries, ACID guarantees, normalization, joins, and commit logs, but does not walk through database setup or SQL commands.
- Examples
- Uses customer and order tables to illustrate denormalization and a shared-database diagram to illustrate service coupling.
- What you can do after
- Evaluate/understand when to retain service-specific state in a relational database and use Kafka instead of a shared database for exchange.
Build Python Web Apps with Streamlit
A database is an organized system for storing, managing, and retrieving structured or unstructured data.
- How it is used
- Provides persistent storage and retrieval for a CRUD web app.
- How deep it goes
- Explains relational tables and schemas, models entities and relationships, and outlines PostgreSQL setup and SQL operations.
- Examples
- Models users and haikus with a one-to-many relationship and a foreign key between their tables.
- What you can do after
- Apply it via PostgreSQL to model and persist data for a CRUD app.
Read how Build Python Web Apps with Streamlit explains database →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A database is a system that stores and manages persistent structured data for retrieval and modification.
- How it is used
- Stores changing video metadata for a streaming microservice while external storage holds the video files.
- How deep it goes
- Walks through development server configuration and service integration, while deferring database design and data engineering.
- Examples
- Uses a video path record, a MongoDB container, and a Node.js streaming service to demonstrate database integration.
- What you can do after
- Apply it via MongoDB to configure a development database and connect a microservice to its video metadata.
The Quick Python Book, Fourth Edition
A database is an organized collection of persistent data managed for storage, retrieval, and modification.
- How it is used
- Uses databases to retain cleaned data and make it accessible for future retrieval and modification.
- How deep it goes
- Works through Python database access with SQLite and MongoDB examples, while leaving a detailed discussion of databases beyond scope.
- Examples
- Uses a SQLite people table, MongoDB documents, and an open-ended dataset loading and search exercise.
- What you can do after
- Apply it via Python’s sqlite3 to create tables, insert and query records, and commit changes.
Read how The Quick Python Book, Fourth Edition explains database →
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
A database system is software that manages persistent data storage, querying, and updates.
- How it is used
- Stores and queries application data for web shops, WordPress, and enterprise applications running on AWS.
- How deep it goes
- Explains relational database purpose and RDS operating choices, but defers database-system-specific user administration.
- Examples
- Uses a product-and-order web shop, a WordPress MySQL database, and an enterprise SQL application.
- What you can do after
- Operate/configure a relational database with Amazon RDS, including access controls, recovery, availability, and monitoring.
Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains database →
Investing for Programmers
A database is an organized system for storing, retrieving, and managing structured or semi-structured data.
- How it is used
- Organizes reusable prompts and external financial context for retrieval-augmented generation and LLM analysis.
- How deep it goes
- Demonstrates relational DDL and an in-memory vector retrieval workflow, but does not develop database administration or production persistence.
- Examples
- Uses prompt schemas, company placeholders, earnings-call transcripts, filings, document chunks, and similarity-search results.
- What you can do after
- Build it from scratch as a tagged prompt repository or in-memory vector store supporting retrieved context for LLM answers.
Building Web APIs with ASP.NET Core
A database is an organized repository that stores structured data for retrieval and modification.
- How it is used
- Feeds websites, mobile applications, management tools, and analysis services through a web API without exposing the database directly.
- How deep it goes
- Defines DBMS benefits and demonstrates SQL Server creation, credentials, users, and deployment, but defers detailed schema design.
- Examples
- Uses a board-game catalog, the MyBGList database, SQL Server Management Studio, instance logins, and database users.
- What you can do after
- Operate/configure SQL Server by creating databases, logins, users, roles, and separate development and production credentials.
Read how Building Web APIs with ASP.NET Core explains database →
Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
A database is an organized repository that persistently stores data and supports structured access and management.
- How it is used
- Uses structured storage to replace spreadsheet-based data handling in PowerShell automation and support repeatable reporting.
- How deep it goes
- Explains connections, database creation, table design, typed columns, and module reuse, but defers administration, backups, and report production.
- Examples
- Demonstrates SQL Server Express setup and a disk-inventory table populated from PowerShell-generated objects.
- What you can do after
- Operate/configure a SQL Server database from PowerShell and organize inventory data for automated reporting.
MongoDB 8.0 in Action, Third Edition
A database is a logical container that organizes related collections or tables and their stored data.
- How it is used
- Organizes MongoDB collections and their documents within a deployment.
- How deep it goes
- Defines the data hierarchy and works through shell selection, first-write creation, naming limits, and reserved databases.
- Examples
- Uses a mongosh insertion that creates a database and an Atlas CLI job that populates test databases.
- What you can do after
- Operate/configure it with mongosh to select a database and create it on first insertion.
Read how MongoDB 8.0 in Action, Third Edition explains database →
Platform Engineering on Kubernetes
A database is an organized data store that supports persistent storage and retrieval of application data.
- How it is used
- Supports persistent, shared application state while services scale across Kubernetes replicas.
- How deep it goes
- Explains persistence, replica sharing, database selection, provisioning, and connection limits, but not database internals.
- Examples
- Uses Redis for Agenda items, PostgreSQL for proposals, and a PostgreSQL Helm Chart deployed inside a Kubernetes cluster.
- What you can do after
- Operate/configure persistent stores with Helm Charts and account for database connection limits when scaling services.
Read how Platform Engineering on Kubernetes explains database →
Microsoft Azure in Action
A database is an organized logical store within a Cosmos DB account that contains collections or containers of data.
- How it is used
- Organizes containers or collections within a Cosmos DB account so applications can group and manage stored documents.
- How deep it goes
- Defines the account-database-container-document hierarchy and demonstrates database creation, but defers broader Cosmos DB scaling details.
- Examples
- Uses alpacacosmosdbaccount, alpacacosmosdb, and alpacacontainer in Azure CLI commands and a hierarchy diagram.
- What you can do after
- Operate/configure a MongoDB database and collection under a Cosmos DB account using Azure CLI.
Just Use Postgres!
A database is a named collection of database objects such as schemas, tables, views, and indexes.
- How it is used
- Organizes application data and workloads into isolated, queryable collections of schemas and database objects.
- How deep it goes
- Defines databases through schemas, tables, and object boundaries, but stops short of detailed administration or deployment guidance.
- Examples
- Uses the default postgres database, a Postgres container, and psql commands for connection and object inspection.
- What you can do after
- Operate/configure it by connecting with psql and recognize the scope of queries across databases and schemas.
Road to Kubernetes
A database is a system that persistently stores and manages structured or semi-structured data for applications.
- How it is used
- Frames databases as stateful dependencies that make otherwise independent web applications practical.
- How deep it goes
- Explains database deployment through volumes, StatefulSets, Secrets, initialization, and Services, but defers clustered-database construction.
- Examples
- Uses PostgreSQL manifests with credentials, a 20Gi volume claim, an init container, and a ClusterIP Service.
- What you can do after
- Operate/configure PostgreSQL on Kubernetes with persistent storage, Secret-backed credentials, and internal Service connectivity.
Grokking Software Architecture
A database is a software system that stores, organizes, and retrieves persistent data.
- How it is used
- Positions database choice and schema design as architectural decisions shaped by data integrity, latency, and workload.
- How deep it goes
- Explains database tradeoffs, schema design, indexes, data types, and SQL debugging, while stopping short of database administration.
- Examples
- Uses shopping-cart, billing-ledger, similar-products, and product-catalog workloads, plus an ORM-backed blog query.
- What you can do after
- Evaluate database choices by workload and diagnose abstraction-related query problems using SQL fundamentals.
Crack Any Codebase with AI
A database is an organized system for storing, managing, and retrieving structured data.
- How it is used
- Organizes application data and provides the contract that queries and generated clients depend on.
- How deep it goes
- Explains tables, columns, rows, schemas, constraints, enums, JSON, and indexes through a minimal SQL definition.
- Examples
- Uses a booking system with booking, event_type, attendee_email, status, metadata, and time-based indexes.
- What you can do after
- Evaluate/understand schemas as structural maps and business-rule artifacts, and recognize mismatches that can break queries.
Functional Design and Architecture: Examples in Haskell
A database is an organized system for storing, managing, and retrieving structured data.
- How it is used
- Provides an external persistence subsystem for application data and a boundary between storage technology and application logic.
- How deep it goes
- Descends from architectural placement to relational schemas, normalization, indexes, SQL, and ORM challenges.
- Examples
- Uses relational storage in the Andromeda architecture and a raw, then type-safe, key–value database subsystem.
- What you can do after
- Evaluate requirements, storage technologies, schemas, access libraries, and abstraction boundaries for application persistence.
Read how Functional Design and Architecture: Examples in Haskell explains database →
Rust Servers, Services, and Apps
Database persistence is the storage of application data in a database so that it survives process termination and can be retrieved later.
- How it is used
- Backs Rust web APIs and frontend handlers with stored course data and user credentials.
- How deep it goes
- Builds from an async PostgreSQL connection and query to service-level persistence and CRUD, while leaving distributed errors for later treatment.
- Examples
- Uses course creation and retrieval, tutor credential lookup, and database container packaging as examples.
- What you can do after
- Build a Rust web service that stores and retrieves course data through a PostgreSQL-backed API.
Read how Rust Servers, Services, and Apps explains database →
Simple Object-Oriented Design: Create clean, maintainable applications
A database is a system that persistently stores and retrieves structured application information.
- How it is used
- Anchors backend operations that retrieve, insert, update, and delete application information.
- How deep it goes
- Defines the database’s architectural role and access boundary but defers storage technology and implementation details.
- Examples
- Uses training courses, employees, trainers, enrollments, reports, and notifications as stored application information.
- What you can do after
- Understand how a database fits into a backend and how repositories isolate persistence logic.
Read how Simple Object-Oriented Design: Create clean, maintainable applications explains database →
ASP.NET Core in Action, 3e
A database is an organized collection of data managed for storage, retrieval, and processing.
- How it is used
- Organizes application data for storage, retrieval, and processing through object-relational mapping.
- How deep it goes
- Defines relational mapping and surveys production concerns without detailing migration or concurrency implementations.
- Examples
- Uses SQL Server, SQLite, MySQL, PostgreSQL, Cosmos DB, and temporary in-memory databases as concrete technology examples.
- What you can do after
- Evaluate database options and understand how EF Core maps .NET classes to relational tables and rows.
Code Like a Pro in Rust
A database is an organized system for persistently storing, retrieving, and modifying structured data.
- How it is used
- Provides persistent state for a REST API implementing todo-item CRUD operations.
- How deep it goes
- Explains database placement, configuration, typed query mapping, CRUD methods, binding order, and error conversion.
- Examples
- Uses a todo table, Todo struct, SQLite queries, connection pools, and create, read, update, delete, and list methods.
- What you can do after
- Apply it via Rust and SQLx to implement typed asynchronous CRUD access for a web service.
Digital Twins in Action
A data store is a software system or repository that persists and retrieves data.
- How it is used
- Stores digital twin models and data for monitoring, analytics, and automation.
- How deep it goes
- Explains relational storage and ACID tradeoffs, demonstrates an SQL query, and provides criteria for selecting among storage types.
- Examples
- Uses an asset, work orders, and maintenance tasks to demonstrate an ad hoc SQLite query.
- What you can do after
- Evaluate storage options against workload latency, scale, consistency, cost, and integration complexity.
Python How-To
A database is an organized collection of data managed for storage, retrieval, and modification by software.
- How it is used
- Hosts task-management application data while the project moves from individual techniques to a working application.
- How deep it goes
- Explains SQLite setup, parameterized insertion, batch insertion, guarded updates, and data-type limitations, but stops short of broader database administration.
- Examples
- Uses task records such as Laundry, Homework, and Museum to demonstrate single-record, batch, and conditional updates.
- What you can do after
- Operate/configure SQLite to insert individual or multiple records and safely update an existing application record.
The Coder Cafe
A database is a system that stores, organizes, and retrieves structured data while providing defined access and integrity guarantees.
- How it is used
- Frames databases as systems that make reliability promises and expose the costs of preserving them across single-node and distributed deployments.
- How deep it goes
- Defines ACID and works through atomicity and consistency, while connecting isolation, durability, and distributed mechanisms without detailing their implementations.
- Examples
- Uses bank transfers and coordinated database writes with Kafka to demonstrate atomicity and system-wide all-or-nothing behavior.
- What you can do after
- Evaluate database guarantees and vendor claims by identifying their reliability promises and distributed-systems trade-offs.
Learn Haskell by Example
A database is an organized system for storing, retrieving, and managing structured data.
- How it is used
- Deploys a database layer to persist todo entries behind a module used by a server API.
- How deep it goes
- Explains schema setup, queries, transactions, parameter binding, generated identifiers, and error handling through implementation listings.
- Examples
- Uses a todo-entry table, SELECT retrieval, id lookup, transactional insertion, and checked-field updates.
- What you can do after
- Apply it via Database.SQLite.Simple to build a small transactional persistence layer for a todo API.
Spring Start Here, Second Edition
A database is an organized collection of data stored for retrieval and management.
- How it is used
- Stores data that backend applications manage and need to persist.
- How deep it goes
- Situates database persistence in backend architecture but does not explain database internals or access procedures.
- Examples
- Uses bank transactions and web or mobile banking clients to illustrate persisted data.
- What you can do after
- Apply Spring to connect an application to a database and work with persisted data.
Read how Spring Start Here, Second Edition explains database →
Also covered in
- Build and Orchestrator in Go (From Scratch)
- ScyllaDB in Action
- Grokking Relational Database Design
- Cloud Observability in Action
- Natural Language Processing in Action, Second Edition
- Advanced Algorithms and Data Structures
- Software Engineering for Data ScientistsIn early access (MEAP)
- Kafka Streams in Action, Second Edition
- Troubleshooting Java, Second Edition
- Unit Testing Principles, Practices, and Patterns
- Kubernetes for Developers
- Learn SQL in a Month of Lunches
What to know first
- SQLSQL is a standardized declarative language for defining, querying, and manipulating data in relational database systems.
- NoSQL databaseA NoSQL database is a database system organized primarily around nonrelational data models rather than the traditional relational table model.
- database tableA database table is a relational data structure that organizes records into rows whose values correspond to defined columns.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
Related concepts
- SQLused by · SQL is a standardized declarative language for defining, querying, and manipulating data in relational database systems.
- PostgreSQLincludes · PostgreSQL is an open-source object-relational database management system that stores and queries data using SQL and supports extensible data types and operations.
- integration testused by · An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
- Entity Framework Coreused by · Entity Framework Core is a cross-platform object-relational mapper for .NET that enables applications to work with databases through .NET objects and queries.
- Apache Kafkacontrasts with · Apache Kafka is a distributed event-streaming platform for publishing, storing, and processing streams of records.
- Retrieverused by · A retriever is a software component that searches or queries an information source and returns items relevant to a query for use by downstream processes.
Questions about database
What is database?
A database is an organized persistent data store, typically managed by software, that supports storing, retrieving, and modifying data.
Which Manning books explain database?
A Pythonic Adventure: From Python basics to a working web app, Coding with AI, Data Analysis with LLMs, Build Financial Software with Generative AI (From Scratch), Apache Kafka in Action, Build Python Web Apps with Streamlit, Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform, The Quick Python Book, Fourth Edition and 21 more.
What should I know before learning database?
Manning books that teach database usually introduce SQL, NoSQL database, database table and JSON first.
What is the difference between database and Apache Kafka?
A database is an organized persistent data store, typically managed by software, that supports storing, retrieving, and modifying data. Apache Kafka is a distributed event-streaming platform for publishing, storing, and processing streams of records.
What kinds of database are there?
Kinds of database include PostgreSQL.
What is database also called?
Database is also called DB.
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.




























