// I need to

ModernizeUpgrade without breaking it RescueFix what someone else started Build NewTurn an idea into a product Reach More PeopleGet found, get used, include everyone

// Company

Case StudiesExpertiseAbout + CareersResourcesContact Book a call →

The Fractalization of Requirements

Requirements fractalization, focus on little used details, or lack of developer and stakeholder involvement can all actively harm the best architecture.

Art+Logic May 31, 20164 min read

From the Art+Logic archive · written in 2016. The tools may have moved on; the thinking still holds.

Fractalization of Requirements - Image courtesy Rodd Halstead

Gathering requirements for software development projects has always been a difficult process, and has veered through various methodologies like waterfall and agile. Regardless of the methodology, though, there are certain pitfalls to deciding and describing just what an application should do that can result in projects stumbling or failing. Requirements fractalization, focus on little used details, or lack of developer and stakeholder involvement can all actively harm the best architecture.

Requirements Fractalization

Requirements Fractalization

Remember learning about fractals in math or science class? They’re repeating patterns that can be viewed at any scale. That is, keep zooming in on a fractal and you’ll keep seeing the same image, and the same complexity.

When a project is first estimated, requirements are usually written at a high level with relatively little attention to detail. That’s especially true today, with the current focus on early releases, beta software, and fast iterations. Why write down a lot of details that are likely to be thrown away before implementation when the first customer release sends the app in a completely different direction?

But it’s easy to imagine how this lack of detail in an initial project proposal affects the reliability of an early project estimate: a line item like “there should be reports” might result in a week or two of work, or six months.

One common sign that an early estimate was too optimistic, with troubling repercussions on budget and schedule, is when the high level requirements expand fractally. A client and developer sit down to identify a project requirement and determine:

Requirements Fractalization

80/20 and 90/90 Rules

When requirements fractalization starts to occur, it’s worth remembering the 80-20 rule (more formally known as the Pareto principle):

Roughly 80% of the effects come from 20% of the causes. , Joseph M. Juran, using work by Vilfredo Pareto

This applies to land ownership (80% of land is owned by 20% of people), sales (80% of sales come from 20% of customers), and various other enterprises. In software, it applies in two important ways:

Although the latter often feels more along the lines of the 90-90 “rule”:

The first 90 percent of the code accounts for the first 90 percent of the development time. The remaining 10 percent of the code accounts for the other 90 percent of the development time. , Tom Cargill, Bell Labs

It’s easy to follow a logical path from each important feature through all the possible ramifications, and end up with individually sensible but collectively impractical solutions for each one. In the aggregate, these minor details are too expensive and not useful enough. For each step away from a key feature, consider: How often might this requirement detail get used? Is there a simple workaround that can sidestep this chain of requirements?

If the requirement detail wasn’t originally listed as a key feature, or doesn’t clearly set the application apart from the competition through an excellent and commonly accessed user experience, strongly consider any inexpensive alternative, even a “This feature isn’t yet finished” alert or an automatic email to customer service.

Developer and Stakeholder Input on Complexity

It’s easy to fractalize features when writing a requirements document. Common causes include assuming:

  1. Implementation of a detail is simple
  2. A feature will be unusable without a particular detail

There are a few ways to counteract these causes throughout the life of a project. Fractalization in requirements planning is common and often unavoidable, so the key is recognizing it and preventing it from diverting the immediate focus of a project. If a team is susceptible to it, then it’s helpful to integrate these steps throughout all stages of the project, not just early planning.

Review the requirements document with people who wear different hats

Typically a project manager and client contact will collaborate on a set of requirements. After a first draft has been written, it’s often helpful to bring in a developer, who can identify unexpectedly expensive details or suggest ways to transform disparate details into a simpler, reusable approach; and a stakeholder, like a CEO, who can authoritatively nix less-important details.

Actively encourage individual developers to speak up when confronted with a fractal requirement…

or one that can be satisfied more simply than outlined. Pre-development document reviews can be tiring and tend to be skipped entirely if planning time runs short. But a developer ultimately digests each detail, and can feel either empowered to speak up to reduce project cost and complexity, or restricted to literal, unquestioning implementation.

View written requirements as tentative plans…

that can be adjusted to better reach the real goals of the application. Developers will only feel inclined to suggest changes if the requirements owner tends to accept those changes or work towards a simpler approach, rather than resolutely champion the primacy of the requirements document.

Maintain a backlog of requirements details…

that get shifted out of early releases. A feature detail may be important or useful but still need to be delayed in order to release a product sooner. A growing list of these delayed details can provide more confidence in the act of shifting them out of the current development cycle.

Above all, reflect on the ultimate goals of the project frequently, and remember that it’s better to release a triangle than never finish a snowflake.

keep going

More to explore in Reach More People.

All Reach More People resources →
let's talk

Got a problem like this one?

Tell us what's stuck. A real person replies within one business day.

Talk to our team →

Talk to people who know software, not a sales script.

Your first call is with Aja, our VP of Sales. He'll help make sure you're solving the right problem. Here's what you'll cover together:

  1. What you're trying to accomplish

    The business goal first, then the technology.

  2. Possible approaches

    And the tradeoffs of each, in plain language.

  3. Risks you may not have considered

    Technical and business, before they cost you.

  4. Whether AI changes the math

    What's practical, and what's just hype for your project.

  5. Sensible next steps

    Even if the right next step is not us.

book-a-call.ics

Loading the scheduler…

Open the booking page →

Some problems are easier to explain in writing. Send us a few lines about what you're working on, and we'll reply within one business day. Helpful to include:

  1. What the software does, or should do
  2. What's stuck, or what's worrying you
  3. Any deadline or budget you have in mind
note.md

Loading the form…