Why a maximum hierarchy depth of 3 won't yield 16 top-level clusters in Relativity clustering

In the Relativity Project Management world, thinking in layers can feel a bit like organizing a busy cabinet: you want the right things in the right folders, easy to reach, but not so tangled that you can’t find them. Here’s a small puzzle many students stumble over—the kind of thing that helps you see how depth affects structure. If the default maximum hierarchy depth is set to 3, can you end up with 16 top-level clusters? The short answer is no. Here’s why, in plain terms with a few useful examples.

Let’s slow down and decode what “maximum hierarchy depth” actually means

Think of a hierarchy as a tree. The root of the tree sits at level 0. Every branch beneath it goes down a level: level 1, level 2, level 3, and so on. The maximum hierarchy depth of 3 means the tree can extend down to four levels in total (levels 0 through 3). It’s not about how many roots you have—it's about how far down you can go from the top.

To keep it concrete, imagine you’re mapping your project into clusters that help organize documents, tasks, and notes. At the top, you have one big umbrella cluster (level 0). Under that umbrella, you can create subclusters (level 1). Each of those can spawn their own subclusters (level 2), and those can spawn more (level 3). That’s four levels in all, but the topmost level—the actual “top-level” cluster—remains a single root in this single-hierarchy setup.

A tiny math detour that sheds light

If you want a mental model that’s quick and honest, line it up like this:

• Level 0: 1 top-level cluster (the root)

• Level 1: if you create 2 subclusters under that root, you’ve got 2 at level 1

• Level 2: each of those 2 could split into 2 more, giving 4 at level 2

• Level 3: each of those 4 could split into 2 more, giving 8 at level 3

That’s a perfectly valid layout with maximum depth 3. But notice what happens to the count of top-level clusters: there’s still only 1 root. The number 16 doesn’t appear as “top-level clusters” in this single-root structure. If you want 16 top-level clusters, you’d be talking about 16 separate roots, which is a different architectural choice—essentially a collection of independent hierarchies, not one tree with depth 3.

Where the confusion often comes from

Some folks glance at the numbers and think “depth 3 means three levels under the top, so there must be multiple top-levels somehow.” But depth is about how far you can go downward, not how many roots you start with. It’s like confusing the number of drawers with the number of desks you own. You could have a single desk with four drawers (depth 3 in a single tree), or you could have sixteen separate desks, each with their own drawers. The latter is valid, but it isn’t the same single hierarchy scenario being described by a depth limit.

What this means for practical project mapping in Relativity

In a real-world setup, depth shapes how you categorize files, tasks, and notes. A shallow depth keeps things fast to scan; you don’t need to chase multiple levels of folders to find what you need. A deeper structure lets you drill down into more precise subcategories, but it can slow you down if you overthink the nesting.

Here’s a pragmatic way to think about it:

• If your objective is clarity, aim for a root with a handful of well-defined subclusters. You’re balancing breadth (how many top-level clusters you actually have) with depth (how many levels you’ll need to reach a specific item).

• If you’re tempted to push depth higher to squeeze in more detail, pause and check whether a new top-level cluster (a new root) might be the better home for a new domain of work. Sometimes creating a separate root makes more sense than piling a bunch of subtopics under one root.

• Remember the user experience. People who search for or navigate your project materials will thank you for a structure they can “read” at a glance. If it feels like a labyrinth, you’ll lose momentum fast.

A quick example you can relate to

Let’s say you’re organizing a litigation project in Relativity. You start with one top-level cluster called “Case X.” Under it, you create Level 1 clusters like “Pleadings,” “Evidence,” and “Correspondence.” Level 2 might have subsets such as “Pleadings: Motions,” “Pleadings: Answers,” and “Pleadings: Replies.” Level 3 could go even deeper with specific document groups or issue tags.

• Level 0: Case X (1 top-level)

• Level 1: Pleadings, Evidence, Correspondence (3 subclusters)

• Level 2 under Pleadings: Motions, Answers, Replies (3 subclusters)

• Level 3 under Motions: Scheduling, Filings, Court Orders (3 subclusters)

If you map it like this, you’ll notice the number of top-level clusters stayed at 1. The depth gave you more layers to organize, but it didn’t magically multiply the root into sixteen.

How to think about depth vs. scalability in tools you might use

Even outside Relativity, many data organization systems let you choose depth and, separately, how many top-level categories you want. The key is to keep a mental model aligned with what you’re actually building:

• Depth is the ceiling your hierarchy can reach.

• Top-level clusters are the roots of each independent tree, if your system supports multiple trees.

• Branching factor (how many children each node can have) determines how big the tree grows with a given depth.

If you’re aiming for a certain number of top-level clusters, ask yourself: Do I want a single, coherent structure, or do I want several independent domains? The decision will guide whether you keep one root or create several.

A few practical pointers for Relativity PM workflows

• Start with a clear purpose for each top-level cluster. It keeps the structure intuitive when new documents or tasks come in.

• Use consistent naming conventions across levels. It reduces cognitive load and speeds up retrieval.

• Limit the level count where possible. If four levels feel like too many, consolidate. If you genuinely need deeper analysis, consider a parallel root for a new domain rather than deeper nesting.

• Validate with a quick user test. A colleague or two can tell you if the layout makes sense in real tasks, not just on paper.

Closing thoughts: depth as a design choice, not a number to chase

Here’s the takeaway you can carry into your next map or schema design: Maximum hierarchy depth of 3 sets a limit on how far you can descend in one tree, not on how many top-level clusters you can have. With depth 3, you can have a single top-level root and up to three more levels below it, yielding a tidy four-level structure. If you’re hoping for 16 top-level clusters, that implies multiple roots or an entirely different architectural approach, not a simple application of a depth limit.

Relativity projects love clarity, speed, and a rhythm that keeps teams moving. By understanding the interplay between depth and the count of root clusters, you can craft structures that feel natural to navigate and easy to grow. It’s a small design choice, but it lands with real impact—like organizing a big toolbox so the right wrench is never far away.

If you’re curious to see how these ideas translate into your own setups, try sketching a quick tree for a fictional project. Start with one root, play with two or three subclusters at the next level, and then decide whether you’ll stop at depth 3 or open a new root for a separate domain. You might be surprised by how a simple diagram clarifies the work ahead.

• Quick recap you can bookmark:

• Maximum hierarchy depth refers to how far down a single tree can go.

• With depth 3, you can have levels 0 through 3, which means one top-level cluster in a single hierarchy.

• To have 16 top-level clusters, you’d need multiple roots or an entirely separate structure, not just deeper nesting.

• Practical mapping benefits from a balance of depth, breadth, and clear naming.

As you map more projects or documents, keep that mental image of a tree in your head. It’s a surprisingly effective anchor for making sense of complexity, one branch at a time. And if you ever feel your structure getting a bit too tangled, step back, redraw the root, and check whether a fresh root might actually simplify things rather than piling more layers on top.