Agile Processes for HardwareDevelopment

AbstractHardware and software development are quite different, in terms of the concrete developmentalactivities. Thus it might seem that Scrum, the Agile process often used for software development, wouldnot be appropriate for hardware development. However, most of the obvious differences betweenhardware and software development have to do with the nature and sequencing of deliverables, ratherthan unique attributes of the work that constrain the process. The research conducted for this paperindicates that a Scrum process is quite appropriate for hardware development. Thus this paperdescribes a practical Agile process for Agile hardware development, which is almost identical to theScrum process as it is commonly used for developing software.AcknowledgmentsThe author would like to thank John Carter (of TCGen) and Dr. Scott Elliott (of TechZecs LLC) for theircritical contributions in the areas of hardware development and survey design. This document would nothave been possible without their continued participation in every aspect of the research and writing overthe last year and a half, including designs for various figures, textual revisions, and numerous proofreadings.2

Contents1Introduction . 72The Agile Hardware Research Project . 73Processes for Software Development . 84563.1The Waterfall Process for Software Development . 83.2The Adaptive Spectrum . Error! Bookmark not defined.3.3Agile Processes for Software Development . 93.4Scrum Time Horizons and Cycles . 10Hardware vs. Software: Similarities and Differences . 124.1Similarities between Hardware and Software Development . 134.2Differences between Hardware and Software Development . 13Scrum-Process Customizations for Hardware Development . 145.1.1Story Types . 145.1.2Sprint Length . 155.1.3Release Planning . 165.1.4Variation in Sprint Focus during a Release Cycle . 17Agile Process for Hardware Development . 186.1Overview . 196.2Velocity . 196.3Levels of Governance . 206.4Roles . 206.4.1Project-Level Roles . 206.4.2Program-Level Roles . 216.5Artifacts . 226.5.1Product Backlog Items . Stories . Stories . . 256.5.2Epics . 266.5.3Product Backlog . 276.5.4Sprint Backlog . 273 of Done . 27Ceremonies . 286.6.1Estimation Concepts. for PBI Estimation . Sizing . Sizing . 306.6.1.2How to Estimate Team Velocity . 306.6.1.3How to Estimate PBIs with Planning Poker . 316.6.1.4How to Estimate Tasks . 326.6.2Ceremonies for Sprints . 326.6.2.1Backlog Grooming Meeting . 346.6.2.2Sprint Planning Meeting . 346. Planning, Part 1 . 356. Planning, Part 2 . 356. to Allocate Team Members to PBIs . 366.6.2.3Daily Stand-Up Meeting . 376.6.2.4Sprint Review . 376.6.2.5Retrospective . 386.6.3Ceremonies for Releases . 396.6.3.1Release Planning . 426. Release Planning Meeting . 426. Release Planning . 446. Development and Estimation . 446. Plan Development . 446. for Estimation in Release Planning . 446. to Estimate PBIs and Epics for Release Planning: Affinity Estimation. 456.6.4Scrum-of-Scrums Meeting . 466.6.5Product Owner Scrum of Scrums Meeting . 466.6.6Release Review . 476.6.7Release Retrospective. 476.7Tracking and Metrics . 486.7.1Tracking Progress for a Sprint . 484 Progress for a Release . 49How Requirements are Developed . 50Practical Example of an Agile Hardware Project . 517.1The Project and Product Definition . 527.2The Team Definitions . 527.3Developing High-Level Specifications . 557.4Developing Detailed Specifications . 577.5Release Planning . 587.5.1Developing the Release Plan . 597.5.2The Structure of the Release . 597.6Regulatory Issues . 617.7How Scope and Work Evolve during the Release Cycle. 628Conclusions . 629Glossary . 635

List of FiguresFigure 1: Winston Royce's original Waterfall Diagram . 8Figure 2: The Five Cycles of Planning in Scrum. 11Figure 3: Release-Level View of Concurrent Hardware and Software Development. 19Figure 4: Sample User Story . 24Figure 5: Sample Technical Story for Software Development . 24Figure 6: Sample Technical Story for Hardware Development . 25Figure 7: Decomposition of an Epic into PBIs . 26Figure 8: A Typical Definition of Done for a Software Team's PBIs. 28Figure 9: A Typical Definition of Done for a Hardware Team's PBIs . 28Figure 10: Typical Sprint Schedule . Error! Bookmark not defined.Figure 11: Typical Release Schedule. Error! Bookmark not defined.Figure 12: A Release Plan, as it Appears in the Release Planning Meeting . 43Figure 13: An Example of Affinity Estimation. 46Figure 14: Scrum Taskboard with Burndown Chart . 49Figure 15: A Typical Burn-Up Chart . 50Figure 16: Scrum Teams for Cardiac Monitor Development . 54Figure 17: Network Diagram for Cardiac Monitor Development . 56Figure 18: A Typical Epic for a Major User-Facing Product Capability . 56Figure 19: A Typical Decomposition of Epics into Stories . 58Figure 20: Structure of the Release Cycle for the Cardiac-Monitor Development . 616

1 IntroductionThe introduction of Agile processes for software development has brought many advantages toorganizations that develop software. Relative to the preceding “Waterfall” approach, these advantagesinclude Visibility: Status of work and plans is highly visible, on an hour-by-hour basis Adaptability: The practice of breaking large scope into many small, testable deliverables hasprovided tremendous flexibility to plan, control, and change scope (sometimes dramatically) onshort notice Minimum time to market: Small, high-value requests can be developed and delivered morequickly, in as little as a few weeks in some cases Higher probability of meeting customer needs: More frequent customer testing and feedbackallows a better shot at a moving targetAgile processes are not limited to the world of software development. They can be applied in othercontexts, such as IT Operations and Production support, where they provide benefits similar to thoselisted above.This paper addresses how to apply Agile process concepts to the world of hardware development, andintegration of hardware and software. “Hardware development” here refers to the development ofspecifications for devices that are intended to be manufactured. The goal of this paper is to identifypractical Agile processes for hardware development.2 The Agile Hardware Research ProjectThe discoveries presented in this paper derive from a study performed by Dr. Kevin Thompson (cPrime),John Carter (TCGen), and Dr. Scott Elliott (TechZecs) in 2014. The researchers conducted interviewswith people at fourteen companies that make hardware, software, or combined products.While none of the companies had a standardized, end-to-end Agile process for hardware developmentas such, many used some techniques borrowed from the world of Agile software development. Forexample, we discovered that companies engaged in rapid development of circuit boards throughiterative prototyping, division of product-development cycles into time-boxed Sprints, tracking withBurndown charts, and frequent integration and integration testing of components.Our analysis of the research data, including impacts and constraints due to the inherent characteristicsof hardware product development, has yielded the insights presented in this paper.The following sections describe the characteristics of hardware development that influence or constrainprocess definition, and propose an Agile process for hardware development. We begin by looking firstat Agile techniques for Software Development, and then identify how hardware development resemblesor differs from software development.7

3 Processes for Software DevelopmentThe dominant process for software development, up through roughly the year 2000, was the Waterfallprocess, which was first described by Winston Royce in 1970.1 Although Royce did not coin the term“Waterfall,” he did describe a process whose characteristic stair-step structure and flow inspired theterm. Agile processes were developed and introduced in the 1990s, starting with Extreme Programming,and followed a few years later by Scrum. We look at both approaches below.The Waterfall Process for Software DevelopmentThe basic concept of a Waterfall process is that the project scope (in this case, the feature set of asoftware product) is first defined, and then moves through a sequence of stages until the completeproduct is delivered at the end. Royce diagrammed the process in this SISPROGRAM DESIGNCODINGTESTINGOPERATIONSFigure 1: Winston Royce's original Waterfall Diagram8

Royce’s own commentary on this diagram foreshadows the difficulties to come:“I believe in this concept, but the implementation described above is risky and invites failure.The problem is illustrated in [Royce’s] Figure 4 [Figure 1 above]. The testing phase whichoccurs at the end of the development cycle is the first event for which timing, storage,input/output transfers, etc., are experienced as distinguished from analyzed. These phenomenaare not precisely analyzable. They are not the solutions to the standard partial differentialequations of mathematical physics for instance. Yet if these phenomena fail to satisfy the variousexternal constraints, then invariably a major redesign is required. A simple octal patch or redo ofsome isolated code will not fix these kinds of difficulties. The required design changes are likelyto be so disruptive that the software requirements upon which the design is based and whichprovides the rationale for everything are violated. Either the requirements must be modified, or asubstantial change in the design is required. In effect the development process has returned tothe origin and one can expect up to a 100-percent overrun in schedule and/or costs.”2Royce correctly identified the key problem: It is not possible to get the requirements, design, andimplementation of a product done exactly the right way in a single pass. Every aspect of softwaredevelopment is subject to such high uncertainty that one cannot simply lay out a plan and follow it,because reality diverges swiftly from the plan. Attempts to reduce uncertainty to the point where one cancreate a Waterfall-style plan that works are doomed to failure, because the uncertainty cannot bereduced to low levels.The solution to this problem lay almost thirty years in the future, with the development of Agileprocesses. A core component of this solution is the practice of defining and implementing scope in verysmall pieces, sequentially, and providing frequent opportunities to correct errors and change directionas understanding of the true needs emerges over time.Agile Processes for Software DevelopmentAn Agile process is one that incorporates the principles of the Manifesto for Agile Software Development(commonly referred to as the Agile Manifesto)3, which statesWe are uncovering better ways of developingsoftware by doing it and helping others do it.Through this work we have come to value:Individuals and interactions over processes and toolsWorking software over comprehensive documentationCustomer collaboration over contract negotiationResponding to change over following a plan9

That is, while there is value in the items onthe right, we value the items on the left more.It should be noted that there is nothing inherent in these principles that tie the manifesto to softwaredevelopment in particular, other than the occurrence of the word “software.” Replacing “software” with“product” or “deliverable” retains the philosophy while extending the scope of the Manifesto to a widerworld.The Oxford Dictionary4 defines the word “agile” as “Able to move quickly and easily.” For presentpurposes, a simplified description will suffice for this paper: Agile processes are designed to produceplanned deliverables quickly, while adapting well to uncertainty and unexpected changes.Many Agile software-development frameworks or processes have been defined. Some such as DynamicSystems Development Method (DSDM)5, and Feature Driven Development (FDD)6 are well-defined butare not widely used. Over time, the Agile processes for software development that have becomedominant are Scrum7 and Kanban8.Scrum is the process of choice for environments where key drivers include the need to plan work againsta calendar, and scale to large, multi-Team environments. Kanban is preferred for environments that aremore reactive (i.e., pure bug-fixing or maintenance work), or where there is little need to plan workagainst a calendar. As schedules are usually important for hardware development work, the lessonsfrom Scrum are more relevant for our purposes.Scrum Time Horizons and CyclesScrum has neither the flow of a Kanban process, nor the classic plan-driven structure commonly used inconstruction and many other fields, as exemplified, e.g., by the PMBOK9. Instead, Scrum is a cyclicprocess. A Scrum process commonly consists of nested cycles that span different time horizons,commonly illustrated as in Figure 2.10

* Revise as often as needed (per Release, per Sprint, )Figure 2: The Five Cycles of Planning in ScrumThe above cycles may be defined as follows: Product Vision: Not a plan of work against a calendar, but a concise description of what theproduct is, and is not, that guides development work across multiple versions over time. ProductVisions can be changed, but mainly evolve slowly, over years. Roadmap: A long-term schedule of major milestones, commonly over a span of six months totwo years. The milestones commonly represent the release of new versions of products tocustomers, and are defined by the timing and content of the product releases. Release Plan: The estimated scope (the Release Backlog, or feature set to be developed) for arelease of a product upgrade to customers, for a specific release date. Sprint Plan: The estimated scope (the Sprint Backlog, or deliverables to be developed) for aSprint. Day Plan: The work of the day, carried out in the form of real-time task allocation and adaptationto circumstances.In the simplest case, a Scrum Team plans and executes Sprints (i.e., iterations, or short developmentcycles) of uniform length (two to four weeks) on a just-in-time basis.Any conception of product requirements must produce some scope definition for deliverables to becreated. In a Scrum context, product scope is decomposed into numerous small deliverables, each ofwhich can be developed and tested in a fairly short period of time. The written artifacts (documents) thatprovide these small scope descriptions are known as User Stories (for aspects of the product thatprovide some kind of user experience), Technical Stories (for other deliverables), and Defects (bug11

reports), all of which are discussed in more detail in Section 0. These various artifacts are referred togenerically as Product Backlog Items, or PBIs, as they reside within a set or queue of requests called theProduct Backlog prior to scheduling. PBIs should be small, such that roughly 5 to 15 can be started andcompleted in the same Sprint.This Sprint-level scenario requires that the Scrum Team’s Product Owner develop and rank (sequence)items in the Product Backlog prior to the Sprint Planning Meeting. The Scrum Master facilitates the SprintPlanning Meeting, in which the Team members and Product Owner discuss and clarify the PBIs, theTeam members estimate the PBIs, and the three Scrum roles collaborate to select an achievable set ofPBIs to implement in the Sprint. The Team members decompose the work of each PBI in the new SprintBacklog into Tasks they will perform, and spend the bulk of the Sprint implementing and validating thedeliverables. At the end of the Sprint, they demonstrate the completed deliverables in a Sprint Reviewmeeting, and capture lessons learned and plan how to improve their process in a Sprint Retrospectivemeeting. The Scrum Master monitors the progress and process throughout, and focuses on making theTeam as productive as possible, by removing obstacles, mentoring the Team, and ensuring that theprocess is followed.While this minimal scenario is not uncommon, it is far from universal. Organizations of medium to largesize may have anywhere from several to several tens of Scrum Teams, whose work must besynchronized to avoid chaos, and for which work must be planned over multiple Sprints in a longerRelease cycle. Common techniques for planning and managing cross-Team collaboration anddependencies include Release Planning and Scrum-of-Scrums meetings.4 Hardware vs. Software: Similarities and DifferencesIn this paper, “hardware” refers specifically to electrical or electro-mechanical devices, which oftencontain firmware or embedded software. Examples include networking equipment, phones, and othercommunications technology; consumer electronics; computers; medical devices; ASICs (ApplicationSpecific Integrated Circuits), and so forth. No attempt is made to address specific issues associatedwith motor vehicles, aircraft, construction equipment, or other products, although much of what is saidhere will likely have some relevance to those products as well.Similarly, “hardware development” is taken to mean the development of designs for devices that areintended to be manufactured, which excludes the details of the manufacturing process itself (an areathat has been addressed in great detail by the principles of Lean Engineering).The following sections describe some key differences between hardware and software development,which have important implications for any effective Agile hardware-development process.12

Similarities between Hardware and Software DevelopmentSoftware products, hardware products, and combinations of the two in the same product share thesecharacteristics: They have behavior: Users interact with the products in various ways, products interact withother products, and products produce outputs given inputs They have functional (user-facing) and non-functional (non-user-facing) requirements They are complex: Any representation of product specifications invariably leads to a treestructure, as major features are decomposed into finer-grained featuresDifferences between Hardware and Software DevelopmentSoftware and hardware products differ in these ways: Software is more malleable (easier to change) than hardware. The cost of change is muchhigher for hardware than for software. Software products evolve through multiple releases by a process of accretion and refactoring(adding new features and re-writing existing logic to support the new features). Hardwareproducts consist largely of physical components that cannot be “refactored” aftermanufacturing, and cannot “accrete” new capabilities that require hardware changes. Designsfor new hardware products are often based upon earlier-generation products of similar type, butcommonly rely on next-generation components that were not present in earlier generations of theproduct. New versions of software and hardware products are both constrained by the design andcapabilities of previous versions, but the accretional nature of software development allows formore latitude in deciding what to develop than is the case for hardware. Upgraded versions ofhardware products typically have less scope for major qualitative changes, and focus more onquantitative improvements of existing capabilities. Hardware designs are constrained by the need to incorporate standard parts. Specialized hardware components can have much longer lead times for acquisition than is truefor software. The design for a hardware product is driven in large part by architectural decisions. As the costof change is high, more of the architectural work must be done up front compared to softwareproducts.13

Testing software commonly requires developing thousands of test cases, with perhaps a few toa few tens of new test cases being developed per month over the life of the product. Hardwaretesting involves far fewer tests, but more specialized and expensive equipment. Software testing is commonly done by, or defined by, specialized Quality Assurance (QA)engineers, while hardware testing is commonly done by the engineers who are creating theproduct. Hardware must be designed and tested to work over a range of time (aging) and environmentalconditions, which is not the case for software. Hardware development incorporates four parallel, synchronized projects: 1) The detailed designof the manufacturable product; 2) the manufacturing process and tooling; 3) the test andinspection process and equipment; and 4) the supply chain for purchased parts. In softwaredevelopment, the detailed design is the product, and production deployment consists of movingthe product into a context where it can be used. The cost of development for software products is relatively flat over time (aside from the usualhiring and attrition). However, the cost of hardware development rises rapidly towards the end ofthe development cycle for hardware products. Due to many of the above factors,

Agile Processes for Software Development An Agile process is one that incorporates the principles of the Manifesto for Agile Software Development (commonly referred to as the Agile Manifesto)3, which states We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value: