Granularity
Granularity is the level of detail or size at which information, behavior, or a system is represented, grouped, or divided.
The Well-Grounded Data Analyst
The level of detail at which data or an analysis is represented, such as cities, boroughs, or broader regions.
- How it is used
- Guides data-model structure and transformations so analytical outputs match stakeholder questions.
- How deep it goes
- Works through row-unit definition, uniqueness checks, aggregation, data-quality checks, and forecasting trade-offs.
- Examples
- Uses customer-level models, product purchase events, football tables, city spending, traffic counts, and street-level property comparisons.
- What you can do after
- Apply it to choose row units, aggregate data, validate record uniqueness, and judge whether available detail supports a question.
Read how The Well-Grounded Data Analyst explains granularity →
Effective Data Analysis
Granularity, or grain, is the level of detail represented by a record, observation, or dataset.
- How it is used
- Guides selection of measurement and reporting detail for business metrics and stakeholder decisions.
- How deep it goes
- Defines grain and provides selection questions and tradeoffs across records, organizational hierarchies, geography, and time.
- Examples
- Illustrates grain with doctor visits, business customers and users, geographic groupings, and reporting periods for workflows and A/B tests.
- What you can do after
- Evaluate granularity against a measurement question, stakeholder needs, and the tradeoff between detail and interpretability.
Architecture Modernization: Socio-technical alignment of software, strategy, and structure
Granularity is the level of detail at which a domain story represents a process or business area.
- How it is used
- Sets a single level of detail when scoping Domain Storytelling workshops and domain-process representations.
- How deep it goes
- Distinguishes coarse, medium, and fine levels, and requires each story to remain at one level.
- Examples
- Uses broad business stories, ten-step activity breakdowns, and intention-focused domain events as contrasting levels of detail.
- What you can do after
- Apply it via Domain Storytelling or EventStorming to choose useful detail and keep workshop discussions focused.
Quantization and Fast Inference
The level of tensor partitioning that determines which values share quantization parameters such as a scale factor.
- How it is used
- Guides quantization choices by tensor target, bit-width, architecture, and hardware support.
- How deep it goes
- Compares per-tensor, per-channel, and grouped scaling through MSE, scale-factor overhead, and memory-layout tradeoffs.
- Examples
- Compares INT8 per-channel with per-tensor scaling and FP4 block-16 with INT4 group-128 on weight reconstruction error.
- What you can do after
- Configure tensor-specific scaling schemes by bit-width, then verify runtime support and memory-layout alignment.
Read how Quantization and Fast Inference explains granularity →
Everyday Data Visualization
Grain is the level of detail defined by what one row in a data table represents.
- How it is used
- Defines the first data question to answer before interpreting, joining, aggregating, or visualizing a table.
- How deep it goes
- Explains grain through banking, fruit, and reservation examples, then stops short of detailed join or aggregation procedures.
- Examples
- Uses banking transactions, daily summaries, account snapshots, fruit observations, fruit-type scores, and hotel reservations.
- What you can do after
- Evaluate/understand what each row represents before aggregating data or trusting calculated totals.
Machine Learning System Design
The level of detail at which data is represented, measured, or modeled.
- How it is used
- Guides dataset design and demand-forecasting tradeoffs between computational efficiency, model performance, and product use cases.
- How deep it goes
- Contrasts daily and weekly aggregation, quantifies a sevenfold computation reduction, and stops short of prescribing one universal resolution.
- Examples
- Uses day-store-item and week-store-item demand records as the central granularity comparison.
- What you can do after
- Evaluate data-resolution choices against computation, validation performance, service speed, and stakeholder needs.
Read how Machine Learning System Design explains granularity →
Grokking Concurrency
Granularity is the degree to which a computation is divided into tasks, characterized by the number and size of those tasks.
- How it is used
- Guides the decomposition of concurrent applications into task sizes and counts that use processing resources effectively.
- How deep it goes
- Defines coarse and fine granularity, explains their trade-offs, and stops short of implementation-specific scheduling details.
- Examples
- Contrasts four and eight threads on an eight-core system, including how a scheduler handles fewer available cores.
- What you can do after
- Apply granularity choices when decomposing work, balancing parallelism and runtime coordination overhead.
Spring Microservices in Action
The degree to which a software service's responsibilities are broad or narrowly scoped.
- How it is used
- Guides decisions about microservice responsibilities and when to split a service into smaller units.
- How deep it goes
- Compares coarse- and fine-grained risks and recommends broad-first evolution, without supplying an implementation procedure.
- Examples
- Uses a diagram of a monolithic application's data model being divided into microservices to illustrate decomposition.
- What you can do after
- Apply broad-first design, shape interfaces around service interactions, and revisit boundaries as domain understanding grows.
Read how Spring Microservices in Action explains granularity →
The Design of Web APIs, Second Edition
Rule granularity is the degree to which a linting rule limits its verification to a narrowly defined aspect of an API.
- How it is used
- Guides decisions about what each API linting rule should verify without making feedback overwhelming.
- How deep it goes
- Provides a short rule-planning checklist, but no worked rule implementation.
- Examples
- Uses shared OpenAPI components and concise rule names and descriptions as planning aids, without a worked example.
- What you can do after
- Practice/perform rule scoping by selecting needed checks, splitting broad needs, and naming each rule clearly.
Read how The Design of Web APIs, Second Edition explains granularity →
Building Specialized AI Systems
Label granularity is the level of specificity represented by the categories or annotations in a labeling scheme.
- How it is used
- Guides the design of supervised fine-tuning labels for consistent and appropriately nuanced model outputs.
- How deep it goes
- Contrasts coarse and fine-grained schemes, explains their trade-off, and stops short of prescribing one universal level.
- Examples
- Uses compliance decisions, investment sentiment, earnings and cash-flow components, and domain-expert review samples.
- What you can do after
- Apply it via labeling guidelines that select workable specificity and expose ambiguity before full dataset annotation.
Read how Building Specialized AI Systems explains granularity →
Spec-Driven Development
Specification granularity is the level of detail at which a specification describes required behavior and implementation constraints.
- How it is used
- Evaluate specification workflows by considering how much intent their level of detail preserves for implementation.
- How deep it goes
- Connects granularity to verifiability and authoring and review effort without detailing specific levels.
- What you can do after
- Evaluate specification workflows by considering granularity alongside structure, location, and organization.
Functional Design and Architecture: Examples in Haskell
Granularity is the size of the independently mutable units into which data or computation is divided.
- How it is used
- Uses granularity to choose a concurrent data design for a stateful simulator.
- How deep it goes
- Explains nested mutable layers and contrasts update costs, while deferring deeper STM treatment.
- Examples
- Compares nested MVars with a coarse-grained map in a simulator runtime.
- What you can do after
- Evaluate concurrent data structures by their mutation boundaries and repeated-update costs.
Read how Functional Design and Architecture: Examples in Haskell explains granularity →
Crack Any Codebase with AI
Granularity is the level of detail at which an item or collection of items is examined.
- How it is used
- Guides Git-history analysis by matching commit, file, or code detail to the question being investigated.
- How deep it goes
- Defines three additive Git levels and contrasts their outputs, without developing broader analytical interpretation.
- Examples
- Uses Git log commands, deleted-file listings, a full commit, and a members-auth middleware change.
- What you can do after
- Apply it via Git commands to choose an effective zoom level for repository questions.
Also covered in
- Demand Forecasting Best Practices
- Java Persistence with Spring Data and Hibernate epub
- Kafka for Architects
- Grokking BayesIn early access (MEAP)
- API Design Patterns
- 100 Go Mistakes and How to Avoid Them
- Effective Behavior-Driven DevelopmentIn early access (MEAP)
- The Art of AI Product Development
- Practices of the Python Pro
- Build Python Web Apps with Streamlit
- Authorization in Action
What to know first
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- anomalyAn anomaly is an observation, data state, or behavior that substantially deviates from an expected or prevailing pattern or condition.
- complexityComplexity is the degree to which interacting elements or factors make a system or problem difficult to understand, predict, change, operate, or solve.
- AI modelAn AI model is a computational system that learns or encodes patterns to map inputs to outputs such as predictions, classifications, or generated content.
Related concepts
- data aggregationconfigures · Data aggregation is the process of combining multiple data values, records, or observations into a consolidated or summarized result.
- decompositionpart of · Decomposition is the process of dividing a complex problem, task, or system into smaller constituent parts that can be handled or analyzed separately.
Questions about granularity
What is granularity?
Granularity is the level of detail or size at which information, behavior, or a system is represented, grouped, or divided.
Which Manning books explain granularity?
The Well-Grounded Data Analyst, Effective Data Analysis, Architecture Modernization: Socio-technical alignment of software, strategy, and structure, Quantization and Fast Inference, Everyday Data Visualization, Machine Learning System Design, Grokking Concurrency, Spring Microservices in Action and 5 more.
What should I know before learning granularity?
Manning books that teach granularity usually introduce JSON, anomaly, complexity and AI model first.
What kinds of granularity are there?
Kinds of granularity include geographical aggregation level, material aggregation level and temporal aggregation level.
What is granularity part of?
Granularity is part of decomposition. Decomposition is the process of dividing a complex problem, task, or system into smaller constituent parts that can be handled or analyzed separately.
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.












