Domain model
A domain model is a software representation of the concepts, entities, relationships, rules, and behavior of a problem or business domain.
AI-Powered Developer: Build software with ChatGPT and Copilot
A domain model is the representation of an application’s core business logic, including domain entities, value objects, and domain services.
- How it is used
- Centers business rules and workflows before external interfaces and infrastructure are connected.
- How deep it goes
- Defines the model’s isolation and responsibilities, then develops an ITAM class design through successive refinements.
- Examples
- Uses an IT asset management design with Hardware, Asset, FundingDetails, and alternative depreciation strategies.
- What you can do after
- Apply it via GitHub Copilot to build classes that apply and enforce business rules.
Read how AI-Powered Developer: Build software with ChatGPT and Copilot explains domain model →
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
A domain model is a representation of the concepts, relationships, and rules that constitute a business domain.
- How it is used
- Aligns business language, software design, and modernization decisions around the concepts that matter to a product.
- How deep it goes
- Explains shared terminology through workplace examples and collaborative modeling, with a small code-model experiment rather than detailed implementation guidance.
- Examples
- Uses disputed device activation, trust-based royalty data matching, and evolving airline domain boundaries.
- What you can do after
- Practice/perform collaborative modeling to clarify terms and rules, test concepts against code, and revisit boundaries as new behavior emerges.
Java Persistence with Spring Data and Hibernate epub
A domain model is an object-oriented representation of application-domain concepts, their state, and their relationships.
- How it is used
- Organizes business entities and rules so application logic can work with objects instead of database rows.
- How deep it goes
- Develops conceptual analysis into persistent Java classes and mapping concerns, while leaving detailed mapping options for later treatment.
- Examples
- Uses an online auction’s items, bids, users, categories, addresses, and billing details to make modeling choices concrete.
- What you can do after
- Build it from scratch by identifying business entities and relationships, then implement the persistent portion as mapped Java classes.
Read how Java Persistence with Spring Data and Hibernate epub explains domain model →
Functional Design and Architecture: Examples in Haskell
A domain model is a structured representation of the concepts, properties, relationships, and behavior of a problem domain.
- How it is used
- Guides domain-first design by keeping business meaning visible while controlling accidental complexity.
- How deep it goes
- Develops representation through classes, interfaces, algebraic data types, and embedded DSLs, while distinguishing domain structure from persistence structure.
- Examples
- Uses an engine-control subsystem, UML class structure, embedded DSLs, and separate key-value persistence and domain representations.
- What you can do after
- Build it from scratch using classes, interfaces, algebraic data types, or interpretable embedded DSLs that reflect domain responsibilities.
Read how Functional Design and Architecture: Examples in Haskell explains domain model →
Automating API Delivery
A domain model is a structured representation of business concepts, relationships, and workflows as interconnected software objects with behavior and data.
- How it is used
- Uses business operations and data models to shape API definitions during plan-and-design work.
- How deep it goes
- Explains the model’s role and inputs, but stops short of low-level API delivery process details.
- Examples
- Uses business operations, data models, user stories, job stories, and resulting API definitions as modeling artifacts.
- What you can do after
- Build it from scratch by modeling business operations and data models before translating requirements into API definitions.
F# in Action: A Revised Edition of Get Programming with F#
A domain model is a software representation of the entities, relationships, rules, and behavior of a problem domain.
- How it is used
- Supports collaborative exploration of real systems before committing ideas to applications or databases.
- How deep it goes
- Works through a train inventory model and its queries, while explicitly deferring time-zone handling.
- Examples
- Uses a train manifest with carriage types, route stops, features, class restrictions, food options, and inventory queries.
- What you can do after
- Build domain models in F# that encode business rules and support queries over structured data.
Read how F# in Action: A Revised Edition of Get Programming with F# explains domain model →
Go in Action, Second Edition
A domain model is a representation of the concepts and relationships in a problem domain that software components conform to.
- How it is used
- Centers modular Go applications on stable business concepts shared by APIs, workers, and other services.
- How deep it goes
- Defines entities, interfaces, and dependency direction, but leaves concrete infrastructure implementations outside the domain.
- Examples
- Uses Article, Feed, Fetcher, ArticleReader, Storage, API, worker, RSS, and Atom examples.
- What you can do after
- Build it from scratch by defining portable entities and interfaces that multiple Go modules can consume without tight coupling.
Read how Go in Action, Second Edition explains domain model →
Unit Testing Principles, Practices, and Patterns
A software model representing the concepts, rules, and behavior of an application domain.
- How it is used
- Prioritizes business-logic testing to maximize return on testing effort.
- How deep it goes
- Defines the domain model and explains its testing priority, but defers detailed isolation techniques.
- Examples
- Uses unit tests, integration tests, infrastructure algorithms, databases, and third-party systems as contrasting testing targets.
- What you can do after
- Apply it via unit testing by isolating business logic and concentrating effort on the most valuable behavior.
Read how Unit Testing Principles, Practices, and Patterns explains domain model →
Related concepts
- domain-driven designused by · Domain-driven design is a software design approach that centers models, structure, and terminology on the concepts, behavior, and boundaries of a problem domain.
- MVC modelequivalent to · An MVC model is the application component that represents application data and associated domain logic, making relevant state and behavior available to other components such as views.
- shared kernelhas part · The shared kernel is a Domain-Driven Design pattern in which bounded contexts share a deliberately coordinated subset of their domain model, code, or data design.
- api modelproduced by · An API-accessible model is a machine-learning model whose capabilities are made available to software through an application programming interface.
- collaborative discovery and modelingequivalent to · Collaborative discovery and modeling is a group technique in which stakeholders jointly create and refine representations to establish shared understanding of a domain or system.
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.