Data model
A data model is a structured representation that defines how data is organized, including its entities, attributes, relationships, and applicable constraints.
The Design of Web APIs, Second Edition
A data model is a structured description of the data accepted and returned by an API operation.
- How it is used
- Defines resource data and operation inputs and outputs after resources, actions, and HTTP data locations are identified.
- How deep it goes
- Works through property selection, types, required status, model derivation, and consumer review; revisits usability and interoperability in a later pass.
- Examples
- Uses online-shopping Product models, banking accounts and transactions, and reusable OpenAPI schemas to illustrate design choices.
- What you can do after
- Build it from scratch: derive operation inputs and outputs from a complete resource model, then describe reusable schemas in OpenAPI.
Read how The Design of Web APIs, Second Edition explains data model →
The Well-Grounded Data Analyst
A formal representation of the entities, attributes, relationships, and constraints in a data domain.
- How it is used
- Standardizes recurring business logic between raw data and analysis so downstream reporting and self-service use shared definitions.
- How deep it goes
- Works through cleaning, entity definitions, deduplication, reshaping, grain, schema, and completeness trade-offs rather than formal modeling theory.
- Examples
- Uses customer consolidation across three sources and football results represented in wide and long formats.
- What you can do after
- Build a reusable customer dataset by consolidating sources, selecting a grain, encoding definitions, and communicating uncertainty.
Read how The Well-Grounded Data Analyst explains data model →
Web Components in Action
A structured representation of the data and relationships an application manages.
- How it is used
- Organizes application state outside rendering components and coordinates shared data flow across Web Components.
- How deep it goes
- Defines models and demonstrates getters, mutations, persistence, derived values, and playback, without detailing storage or event-system internals.
- Examples
- Uses an exercise library, workout-plan object, localStorage-backed saved plans, and playback controls as concrete model examples.
- What you can do after
- Build it from scratch as a JavaScript module that centralizes application data, exposes operations, and coordinates component access.
Effective Data Analysis
A data model is a defined representation of data entities, attributes, relationships, and organization for a particular analytical or operational purpose.
- How it is used
- Uses analytics data models to make warehouse information more useful for recurring business questions and stakeholder decisions.
- How deep it goes
- Explains collaborative modeling choices and star-schema design criteria, without a complete model implementation.
- Examples
- Uses a weather-data integration and sales transactions to illustrate join keys, forecast history, facts, and dimensions.
- What you can do after
- Evaluate and understand analytics models by checking their business relevance, readability, calculations, and support for common analyses.
MongoDB 8.0 in Action, Third Edition
A data model is a representation of the data structures, fields, and relationships that an application stores and accesses.
- How it is used
- Organizes MongoDB documents around application access patterns to support efficient retrieval, scalability, and maintainability.
- How deep it goes
- Works through workload assessment, relationship mapping, pattern selection, indexes, and validation; defers index details.
- Examples
- Uses an airline route workload table and route and airport documents to illustrate subset and computed patterns.
- What you can do after
- Build it from scratch by recording a workload, mapping relationships, selecting patterns, and indexing important queries.
Read how MongoDB 8.0 in Action, Third Edition explains data model →
Python How-To
A data model is a structured representation of the entities, attributes, and relationships in an application domain.
- How it is used
- Guides selection and organization of data representations around application features and maintainability.
- How deep it goes
- Compares container trade-offs and outlines class design and UML review, with custom-class implementation developed further elsewhere.
- Examples
- Uses task fields and container representations, visited places and coordinates, and a Student class with mixed responsibilities.
- What you can do after
- Evaluate and choose representations for application needs, and review class structure for maintainability.
Rust Servers, Services, and Apps
A data model is a structured specification of the data entities, fields, and relationships represented by a software system.
- How it is used
- Shapes course and tutor data as it moves through HTTP handlers, Rust structs, and PostgreSQL tables.
- How deep it goes
- Works through field definitions, JSON conversion, optional values, row mapping, and model refactoring rather than a general modeling method.
- Examples
- Uses a seeded course table, a `Course` struct, and separate registration-form, tutor-response, and user structs.
- What you can do after
- Build it from scratch: define operation-specific Rust structs and align them with HTTP payloads, PostgreSQL columns, and query results.
Read how Rust Servers, Services, and Apps explains data model →
Everyday Data Visualization
A data model is an organizational structure that specifies the kinds of data to store and how each data item is described.
- How it is used
- Organizes collected data so its fields and level of detail can support a planned visualization.
- How deep it goes
- Defines the model, illustrates observation-level and aggregated tables, and gives planning checks without prescribing a full implementation.
- Examples
- Uses a fruit-eating log, fruit-type summaries, hotel reservations, and a dashboard metric list.
- What you can do after
- Build it from scratch by choosing what each record represents, defining its fields, and checking that the structure serves the intended visual.
Secure APIs
A data model is a structured representation of entities, attributes, relationships, and constraints, potentially including validation rules for accepted data.
- How it is used
- Uses schemas to constrain API input and output, prevent corruption, and keep untrusted data from reaching application state.
- How deep it goes
- Explains required and optional properties, enumerations, composition, validation errors, and separate input-output models through focused API examples.
- Examples
- Demonstrates character statuses, printed and electronic books, and payments with identifiers, amounts, currencies, and statuses.
- What you can do after
- Builds API schemas that validate values, separate representations, reject unsafe fields, and expose failures for diagnosis.
Pro Angular 16
A data model is a representation of the entities, properties, and relationships in an application's domain.
- How it is used
- Starts Angular application development by defining the domain data that components and templates use.
- How deep it goes
- Works through descriptive classes, an in-memory data source, and repository operations; defers RESTful service integration in the store example.
- Examples
- Uses a to-do item and list, then a product catalog with sample data and repository methods.
- What you can do after
- Build it from scratch using TypeScript classes, a sample data source, and product repository operations.
Pro ASP.NET Core 7, Tenth Edition
A data model is a structured representation of the real-world objects, processes, rules, and data that constitute an application's domain.
- How it is used
- Provides domain objects for ASP.NET Core features that accept user data, compose responses, and access stored records.
- How deep it goes
- Works from a single class through related entities, context properties, and schema migrations; leaves detailed ORM query behavior to further investigation.
- Examples
- Uses an RSVP response, a product catalog, shipped orders, and calculations to illustrate models of increasing scope.
- What you can do after
- Build it from scratch with C# model classes and an Entity Framework Core context, then evolve database-backed models with migrations.
Read how Pro ASP.NET Core 7, Tenth Edition explains data model →
ASP.NET Core in Action, 3e
A database model represents the application data stored in a database and the structure used to work with that data.
- How it is used
- Supports storing, querying, creating, and updating application data in ASP.NET Core applications.
- How deep it goes
- Explains entities, DbContext, providers, dependency injection, and migrations, but defers advanced EF Core customization.
- Examples
- Uses a recipe API with recipes, ingredients, RecipeService, migrations, and an Identity-enabled ApplicationUser.
- What you can do after
- Build a small EF Core data model, synchronize its database schema, and isolate data access in services.
First-Party Data Activation
A data model is a structured representation of entities, attributes, and relationships used to organize and work with data.
- How it is used
- Organizes customer data for marketing segmentation, campaign analysis, and audience activation.
- How deep it goes
- Compares modeling approaches and their trade-offs without detailing implementation.
- Examples
- Uses a travel company's churn and recent-purchaser roadmap alongside star, snowflake, and data vault schemas.
- What you can do after
- Evaluate modeling approaches against query simplicity, redundancy, complexity, and auditing needs.
The Art of Code
A data model is a representation of the information, structure, relationships, and constraints that a software system manipulates.
- How it is used
- Guides code design by making domain data explicit before arranging behavior around it.
- How deep it goes
- Develops practical modeling and refactoring principles, but stops short of prescribing a rigid universal method.
- Examples
- Uses ambiguous user attributes, typed height and weight values, immutable carriers, and refactoring inspection prompts.
- What you can do after
- Apply it by replacing ambiguous structures with precise, proportionate data types and simpler behavior.
Automating API Delivery
A data model is a representation of the data entities, attributes, relationships, and constraints handled by a system or API.
- How it is used
- Aligns API designers and stakeholders on resources, relationships, terminology, and operations before API definitions are created.
- How deep it goes
- Defines conceptual entities and relationships, represents them with diagrams or tables, and stops short of implementation-level schemas.
- Examples
- Uses a Product Catalog API with products, reviews, categories, cardinalities, relationship diagrams, and an operations table.
- What you can do after
- Evaluate/understand API resource boundaries and relationships, then communicate them through diagrams, tables, and operation definitions.
Functional Design and Architecture: Examples in Haskell
A database model is a representation of how data is structured and related within a database's internal storage system.
- How it is used
- Separates storage representation from domain logic while supporting key–value and relational persistence.
- How deep it goes
- Defines database models, demonstrates serialization and conversion, and addresses database types and key design.
- Examples
- Uses meteor records, KVDBMeteor JSON rows, DBMeteor SQL fields, conversion functions, and primary-key lookup.
- What you can do after
- Apply it via explicit database entities and conversion functions that isolate persistence code from business logic.
Read how Functional Design and Architecture: Examples in Haskell explains data model →
Delivering Machine Learning Projects: From design to deployment
A data model is a formal representation of the entities, attributes, relationships, and constraints represented by data.
- How it is used
- Uses data-model understanding to establish ML readiness and reduce uncertainty before project delivery begins.
- How deep it goes
- Requires documentation and inspection of real data characteristics, but stops short of describing modeling or implementation internals.
- Examples
- Uses a short ML-readiness project, documented data-model work, extraction and inspection, and contingency estimates as practical artifacts.
- What you can do after
- Evaluate data readiness and plan an ML project with informed expectations, governance provisions, and explicit contingency.
Read how Delivering Machine Learning Projects: From design to deployment explains data model →
Data-Oriented Programming: Reduce software complexity
A data model is a structured representation of the data entities, fields, values, and relationships in a system.
- How it is used
- Separates data design from code while organizing entities, fields, values, and relationships for generic manipulation.
- How deep it goes
- Descends from entity diagrams to record structures, relationship representation, information paths, and runtime field changes.
- Examples
- Uses a Library Management System with Book–Author associations, identifier collections, positional collections, and indexed records.
- What you can do after
- Apply it via generic functions such as Lodash get, has, merge, values, filter, and map.
Read how Data-Oriented Programming: Reduce software complexity explains data model →
Essential TypeScript 5, Third Edition
A data model is a structured representation of an application's data and the operations that can be performed on it.
- How it is used
- Structures to-do items and product orders so application code can store data and perform operations on it.
- How deep it goes
- Builds typed entities and collection methods, then demonstrates a compiler error; defers fuller explanation of classes and JavaScript types.
- Examples
- Uses a to-do list with add and completion operations and a product order with quantities and calculated line totals.
- What you can do after
- Build it from scratch as typed TypeScript entities with operations, and recognize a mismatched method argument through compiler feedback.
Read how Essential TypeScript 5, Third Edition explains data model →
Microsoft Azure in Action
A data model is a conceptual or structural representation that defines how data and its relationships are organized.
- How it is used
- Guides the organization, distribution, and retrieval of large, changing datasets in Azure Cosmos DB.
- How deep it goes
- Explains schema flexibility, denormalization, and partitioning with trade-offs, while stopping short of detailed partition-key design.
- Examples
- Uses product documents containing supplier, availability, sizes, colors, ratings, and images to illustrate flexible and embedded data.
- What you can do after
- Apply it via Azure Cosmos DB by designing flexible documents, embedding related data, and selecting partitioning strategies for efficient access.
Graph Neural Networks in Action
A data model is a formal structure that specifies the entities, attributes, relationships, and constraints of a dataset or information system.
- How it is used
- Guides the transformation of domain data into graph structures that downstream analytical systems can query reliably.
- How deep it goes
- Explains a practical design, testing, and refactoring workflow, while deferring detailed implementation of individual graph storage structures.
- Examples
- Uses recruitment referrals, JSON representations, candidate datasets, graph datasets, and published semantic models as concrete artifacts.
- What you can do after
- Build it from scratch by defining, testing, and refactoring a graph model for a domain-specific analytical workflow.
Read how Graph Neural Networks in Action explains data model →
Digital Twins in Action
A data model is an abstract structure that defines how data entities, relationships, and constraints are represented and organized.
- How it is used
- Structures digital twin data to support storage, queries, and analysis across systems.
- How deep it goes
- Explains schema choices and cross-system contextualization, with a fuzzy identifier matching example.
- Examples
- Uses bank customer records and a fuzzy comparison of customer, product, and employee identifiers.
- What you can do after
- Evaluate data-model choices for their effects on storage, analysis, and cross-system interoperability.
Build Python Web Apps with Streamlit
A data model is a structured representation of an application's entities, attributes, relationships, and storage organization.
- How it is used
- Designs an application's entities, relationships, attributes, and relational database schema before implementing CRUD operations.
- How deep it goes
- Explains ER diagrams and table conversion, including primary and foreign keys, without detailing more complex real-world models.
- Examples
- Uses users and haikus with usernames, haiku text, authors, numeric IDs, creation times, and a foreign-key relationship.
- What you can do after
- Apply data modeling to design tables and relationships for CRUD applications using relational databases such as PostgreSQL.
Read how Build Python Web Apps with Streamlit explains data model →
Healthcare IT
A data model is a formal representation of the entities, attributes, relationships, and constraints that organize information in a system.
- How it is used
- Frames EHR events as structured records that preserve actors, state changes, patient linkage, and captured clinical data.
- How deep it goes
- Maps actors, state transitions, patient identifiers, and event data through a CBC timeline.
- Examples
- Uses a CBC order, specimen collection, laboratory analysis, result, encounter states, and an MRN.
- What you can do after
- Build and evaluate workflow records by linking each clinical event to actors, state changes, data, and a patient.
Data-Oriented Programming in Java
A database model is a structured representation of data entities, attributes, and relationships as persisted by a database.
- How it is used
- Uses focused domain data to express business rules and reduce ambiguity in enterprise systems.
- How deep it goes
- Works through semantic types and a customer-account representation, stopping short of a complete enterprise entity.
- Examples
- Uses a customer Account composed of identifiers, enums, country and regional codes, segments, channels, and a Sector record.
- What you can do after
- Build it from scratch with plain data, records, enums, and descriptive types tailored to a business task.
Read how Data-Oriented Programming in Java explains data model →
Grokking Software Architecture
A representation of the data structures, attributes, and relationships that an application stores and manipulates.
- How it is used
- Supports flexible scorecard configuration by separating attribute definitions from application values instead of hardcoding columns.
- How deep it goes
- Compares hardcoded columns with dynamic rows, gives an Entity-Attribute-Value schema, and warns about type safety and query performance.
- Examples
- Uses scorecard metrics such as Same Store Sales, Inventory Turnover, and a Global Risk Factor.
- What you can do after
- Apply dynamic rows to add scorecard fields without schema changes, reserving the pattern for variable metadata.
Read how Grokking Software Architecture explains data model →
Also covered in
- Microservices Patterns, Second EditionIn early access (MEAP)
- ScyllaDB in Action
- Snowflake Data Engineering
- Platform Engineering on Kubernetes
- Building Web APIs with ASP.NET Core
- Crack Any Codebase with AIIn early access (MEAP)
- Django in Action
- Apache Kafka in Action
- Elasticsearch in Action, Second Edition
- F# in Action: A Revised Edition of Get Programming with F#
- Java Persistence with Spring Data and Hibernate epub
- AI Agents in Action, Second Edition
What to know first
- SQLSQL is a standardized declarative language for defining, querying, and manipulating data in relational database systems.
- schemaA data schema is a formal specification of the structure, fields, types, relationships, and constraints of data.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- attributeAn attribute is a named property or piece of information associated with an entity, object, or structured data item.
Related concepts
- schemaproduces · A data schema is a formal specification of the structure, fields, types, relationships, and constraints of data.
- Angular applicationpart of · An Angular application is a web or software application built with the Angular framework.
- data sourcehas part · A data source is an origin, system, repository, or process from which data is obtained or made available for use or processing.
- data structurehas part · A data structure is an organized representation of data and its relationships that supports defined operations for storing, accessing, or modifying it.
Questions about data model
What is data model?
A data model is a structured representation that defines how data is organized, including its entities, attributes, relationships, and applicable constraints.
Which Manning books explain data model?
The Design of Web APIs, Second Edition, The Well-Grounded Data Analyst, Web Components in Action, Effective Data Analysis, MongoDB 8.0 in Action, Third Edition, Python How-To, Rust Servers, Services, and Apps, Everyday Data Visualization and 18 more.
What should I know before learning data model?
Manning books that teach data model usually introduce SQL, schema, contract and attribute first.
What kinds of data model are there?
Kinds of data model include computed pattern.
What is data model part of?
Data model is part of analysis and design. The phase of database design that analyzes requirements and specifies the database's structure and functionality.
What are the parts of data model?
Data model includes data source and data structure.
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.

























