liveBook · Manning

Granularity

Granularity is the level of detail or size at which information, behavior, or a system is represented, grouped, or divided.

How 13 Manning books explain it

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.

Read how Effective Data Analysis explains granularity →

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.

Read how Architecture Modernization: Socio-technical alignment of software, strategy, and structure explains granularity →

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.

Read how Everyday Data Visualization explains granularity →

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.

Read how Grokking Concurrency explains granularity →

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.

Read how Spec-Driven Development explains granularity →

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.

Read how Crack Any Codebase with AI explains granularity →

Also covered in

What to know first

Related concepts

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.