liveBook · Manning

Requirements

A requirement is a stated need, capability, quality, condition, or constraint that a system, product, solution, or project is expected to satisfy.

How 16 Manning books explain it

Lead Developer Career Guide

A specified capability, behavior, or constraint that a software product or feature must satisfy.

How it is used
Guides feature development and aligns technical work with business needs before design and estimation.
How deep it goes
Develops practical clarification and documentation tactics before implementation and QA, without prescribing a formal specification template.
Examples
Uses vague feature requests and a client presentation that overlooked the client’s technical ideas.
What you can do after
Practice/perform clarifying requirements before work begins, then using them to support estimates, budgets, and QA checks.

Read how Lead Developer Career Guide explains requirements →

BDD in Action, Second Edition

A requirement is a stated capability, condition, or constraint that a software system is expected to satisfy.

How it is used
Guides collaborative discovery of needed behavior, then connects that behavior to implementation and evidence of business value.
How deep it goes
Traces requirements from uncertain goals through examples, executable criteria, changes, and coverage; does not treat initial specifications as complete.
Examples
Uses a train-departure change and an authentication feature with pending single sign-on examples.
What you can do after
Practice/perform collaborative refinement, update acceptance criteria when needs change, and assess which defined requirements remain unimplemented.

Read how BDD in Action, Second Edition explains requirements →

Architecting an Apache Iceberg Lakehouse

A storage requirement is an explicit, testable condition that a storage system or architecture must satisfy.

How it is used
Guides lakehouse architecture and tool evaluation by converting organizational needs into testable decision filters.
How deep it goes
Explains an audit-to-requirements process across five lakehouse layers but stops short of selecting specific tools or vendors.
Examples
Uses residency, encryption, archival, low-latency ingestion, regulatory extracts, shared semantics, and dashboard scenarios as requirement examples.
What you can do after
Apply requirements to compare architectures and tools against business value, constraints, implementation effort, and operational tradeoffs.

Read how Architecting an Apache Iceberg Lakehouse explains requirements →

Delivering Machine Learning Projects: From design to deployment

A requirement is a stated need, capability, quality attribute, constraint, or operational condition that a system or project must address.

How it is used
Uses business requirements to assess ML project practicality and delivery risk before funding and detailed investigation.
How deep it goes
Distinguishes functional, nonfunctional, and system requirements and outlines iterative clarification, while noting limits on investigation before commitment.
Examples
Illustrates feasibility with a large model expected to serve many users quickly on an old, slow processor.
What you can do after
Evaluate project practicality by clarifying desired capabilities, performance, operating conditions, and associated risks.

Read how Delivering Machine Learning Projects: From design to deployment explains requirements →

Object-Oriented Software Design in C++

A software requirement is a capability, constraint, or condition that a software system must satisfy.

How it is used
Guides discovery and analysis so developers build the application clients need before refining its internal design.
How deep it goes
Covers quality criteria, elicitation, stated and implied requirements, and initial class analysis, while deferring broader software engineering detail.
Examples
Uses a library card-catalogue automation case involving interviews, observation, customer searches, and prototypes.
What you can do after
Apply interviews, observation, prototypes, validation, and analysis to derive an initial set of application classes.

Read how Object-Oriented Software Design in C++ explains requirements →

Software Design for Python Programmers

A software requirement is a specified capability, constraint, or quality that a software application must satisfy.

How it is used
Guides teams toward building the application clients need before applying techniques to build it well.
How deep it goes
Covers gathering, validation, functional analysis, and initial classes, while deferring detailed requirements engineering.
Examples
Uses client interviews, workplace observation, and a book catalogue with flexible, case-insensitive, wildcard searches.
What you can do after
Apply requirements gathering and analysis to define behavior, identify initial classes, and accommodate later changes.

Read how Software Design for Python Programmers explains requirements →

Build Python Web Apps with Streamlit

Software requirements are stated needs, capabilities, goals, and constraints that a software system is expected to satisfy.

How it is used
Turns an app concept into an agreed scope before user-experience design and implementation.
How deep it goes
Defines capabilities, stakeholders, implementation independence, and exclusions, then stops short of prescribing technical solutions.
Examples
Uses unit-converter and daily to-do-list capabilities alongside explicit exclusions such as currency conversion, logging, export, and persistence.
What you can do after
Apply via a six-step development process to define capabilities, set boundaries, and guide implementation choices.

Read how Build Python Web Apps with Streamlit explains requirements →

Everyday Data Visualization

A stated need, capability, constraint, or condition that a project, product, or system is expected to satisfy.

How it is used
Guides research and planning for a dashboard before its design and iterative development.
How deep it goes
Develops requirements gathering through user interviews about metrics, viewing windows, filters, outputs, and devices.
Examples
Uses a housekeeping scheduler’s three-hotel dashboard to identify staffing metrics, a movable 30-day window, and no mobile-view need.
What you can do after
Practice/perform user interviews to identify dashboard needs and keep the project focused.

Read how Everyday Data Visualization explains requirements →

Functional Design and Architecture: Examples in Haskell

A requirement is a stated capability, constraint, or goal that a software system must satisfy.

How it is used
Guides software design and testing by stating required capabilities and system properties.
How deep it goes
Defines functional and nonfunctional categories with examples, then applies them to contracts and testing.
Examples
Uses spacecraft manual and automatic control, fault tolerance, security, compatibility, and testing contracts as concrete examples.
What you can do after
Evaluate software against functional and nonfunctional expectations through contracts, tests, and design decisions.

Read how Functional Design and Architecture: Examples in Haskell explains requirements →

Coding with AI

Software requirements are specified capabilities, constraints, and qualities that a software system must satisfy.

How it is used
Guides design-document analysis, AI prompting, user-story creation, and application scaffolding.
How deep it goes
Explains extraction steps, structured prompts, user stories, stubs, and validation, but stops short of formal requirements specification.
Examples
Uses a HAM radio test-preparation application, question-pool requirements, random question selection, UI needs, and email-validation prompts.
What you can do after
Apply it via ChatGPT or Gemini to extract, structure, validate, and transform design details into implementation-ready stories and stubs.

Read how Coding with AI explains requirements →

"Looks Good to Me"

A requested capability, behavior, or constraint that software is expected to satisfy.

How it is used
Aligns implementation with business requests and acceptance criteria during feature development and code review.
How deep it goes
Connects requirements to feature discussion and acceptance criteria, but does not prescribe a formal requirements method.
Examples
Uses incomplete pull requests and implementations that solve the wrong problem as failure examples.
What you can do after
Diagnose whether implementation addresses business requests and agreed acceptance criteria.

Read how "Looks Good to Me" explains requirements →

Data-Oriented Programming in Java

A requirement is a stated condition or capability that a software system or process must satisfy.

How it is used
Uses loose or formal statements as the starting point for domain modeling and implementation decisions.
How deep it goes
Refines ambiguity into explicit rules and models, while stopping short of prescribing one complete implementation.
Examples
Uses rocket manufacturing checklists and an auditable late-fee service with customer standing, thresholds, dates, and billing rules.
What you can do after
Build it from scratch by translating ambiguous business statements into precise, explicit domain rules and safer code models.

Read how Data-Oriented Programming in Java explains requirements →

Effective Behavior-Driven Development

A requirement is a statement of a stakeholder need, constraint, or expected system behavior that guides solution development.

How it is used
Guide discovery toward a shared, unambiguous understanding of detailed expected behavior before implementation.
How deep it goes
Develop requirements through workshop examples, rules, and scenarios, while deferring exhaustive combinations and test coverage to delivery testing.
Examples
Uses restricted-customer blocklisting, pay-on-collection, authentication, and email-or-phone matching to illustrate rules and behavior.
What you can do after
Apply requirements by clarifying expected behavior through examples and documenting rules separately from delivery stories.

Read how Effective Behavior-Driven Development explains requirements →

Developer Experience on Kubernetes

A statement of a needed software capability or change, typically accompanied by conditions for considering it complete.

How it is used
Starts software delivery by translating a problem into a change that developers can implement.
How deep it goes
Defines requirements, user stories, and acceptance criteria, then connects them to inner-loop implementation without detailing implementation mechanics.
Examples
Uses appointment-category selection and a Cardiology booking scenario to demonstrate a user story and testable behavior.
What you can do after
Apply requirements by expressing user value, agreeing on completion conditions, and initiating focused implementation work.

Read how Developer Experience on Kubernetes explains requirements →

Collaborative Software Design: How to facilitate domain modeling decisions

A requirement is a stated need, constraint, or capability that a software system is expected to satisfy.

How it is used
Guides software design by expressing user needs before implementation and coordinating stakeholders with developers.
How deep it goes
Contrasts user requirements with implementation details and explains handoff failures, but stops short of a detailed elicitation procedure.
Examples
Uses BigScreen’s back-office reporting, movie-run extensions, database queries, Excel exports, and inaccurate performance metrics.
What you can do after
Diagnose requirements failures by tracing incomplete handoffs, implementation-led stories, and developer assumptions back to the design process.

Read how Collaborative Software Design: How to facilitate domain modeling decisions explains requirements →

Design for Developers

A business need or constraint is a product or project outcome that an organization expects to satisfy.

How it is used
Guides content grouping, wireframing, design approval, testing, and iterative development.
How deep it goes
Defines requirements within a four-phase user-centered process but does not detail formal requirements documentation.
Examples
Uses buying products, booking appointments, comparing hotels, content layouts, wireframes, and approved MVPs.
What you can do after
Apply it via user-centered design to decide when a design is ready for testing and iteration.

Read how Design for Developers explains requirements →

Also covered in

What to know first

Related concepts

Questions about requirements

What is requirements?

A requirement is a stated need, capability, quality, condition, or constraint that a system, product, solution, or project is expected to satisfy.

Which Manning books explain requirements?

Lead Developer Career Guide, BDD in Action, Second Edition, Architecting an Apache Iceberg Lakehouse, Delivering Machine Learning Projects: From design to deployment, Object-Oriented Software Design in C++, Software Design for Python Programmers, Build Python Web Apps with Streamlit, Everyday Data Visualization and 8 more.

What should I know before learning requirements?

Manning books that teach requirements usually introduce stakeholder, software testing, machine learning and capability first.

What is the difference between requirements and user story?

A requirement is a stated need, capability, quality, condition, or constraint that a system, product, solution, or project is expected to satisfy. A user story is a concise requirement describing a desired software capability or outcome from the perspective of a user or stakeholder.

What kinds of requirements are there?

Kinds of requirements include nonfunctional requirement, architectural requirement, business rule and functional requirement.

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.