# Expand an area: Guidelines

> Guidelines for expanding one area of a Johnny.Decimal system – mix and match the rules and principles to suit the situation.

## A common objection

People see this and say, "well what's the point of Johnny.Decimal if I can just make up my own thing?". To which I say: there are no absolutes in life.

I'm trying to be pragmatic and honest. My default system is great for many things, not _every_ thing. We can still use the principles of Johnny.Decimal to stay organised – these are outlined below.

## Consistency is critical

You can build almost any 'shape' of system and be organised. The key is to _be consistent_ in your structure and file naming. This sounds obvious, but if it's front of mind you won't go far wrong.

Help your future self by documenting your scheme and design decisions in your JDex. The standard zero `00.00 Index` would be a good place.

## Rules

### Only expand the part that needs to be expanded

Aim to expand _a single area_ of your system.

Most of what you do should still fit in the standard Johnny.Decimal structure. If you're a freelance designer, manage the rest of your business with standard areas and categories.

### All IDs start with the area number

Standard Johnny.Decimal IDs start with the number of the area they're in: `83.66` belongs to area `80-89`.

You must retain this pattern. You're going to expand one area. Choose that area, and then ensure that every number that it contains starts with the area number.

#### Example

In the [Small Business System](/sbs/), area `50-59` is expanded and uses a five-digit non-standard numbering scheme: `A0000 … A9999`. `A` indicates the area that has been expanded.

In this example, the usable numbers are `50000 … 59999`. Expanding `70-79` the range would be `70000 … 79999`.

---

# Principles

## Use the alphabet

In a standard Johnny.Decimal system, numbers replace the alphabet as the primary sort. This is because most things do not benefit from being sorted alphabetically.

But some things do. For example, if you have a long list of organisations, ordering them alphabetically makes sense.

It makes no sense to allocate the organisations a number and sort numerically. See figure 62.27A below.

## Use the date

Many things benefit from being ordered chronologically: jobs for a client; semesters at university.

And we tend to remember where these kind of things happened 'in time'. So the date can help us find things later.

Look for opportunities to use the date. This must always be specified as year-month-day in the format `yyyy-mm-dd`, e.g. `2024-08-30`. This will sort chronologically in your filesystem.[^iso8601] See figure 62.27A below.

[^iso8601]: This is [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) for the date nerds.

## Stop using numbers

In a standard Johnny.Decimal system, every item has a number: the ID. However in many expand-an-area scenarios, numbers might only make sense at the higher levels.

Use numbers to guide you to the place you need to be. Or where there isn't an alphabet or date alternative.

But when they become a burden, or when the alphabet or date is better, stop using them. See figure 62.27A below.

## Use natural hierarchies

If natural hierarchies exist, use them. Why invent another scheme for something that already has one?

### Example: A freelancer

A freelance designer organises their workload by client, product, then job. Use this hierarchy in your system (or adapt it to your own situation). Don't worry that it breaks the area → category → ID structure. See figure 62.27A below.

## Look for patterns

A sub-principle of 'be consistent': always look for patterns. If you do something over and over it should be a template. This saves time and helps your brain.

Templates usually benefit from having numbers to keep them in order. Numbering in tens (10, 20, 30) makes sense here. It leaves room between items (05, 15, 25) for one-offs or items you forgot.

### Example: A freelancer

A freelance designer creates promotional material for the footwear industry. They have two clients, Joe's Shoes and Tammy's Trainers. Joe makes three products: Big Boots, Cool Kicks, and Sick Sneakers.

The jobs follow a similar pattern. The client provides a brief, copy, images,
and video. The designer produces working files for review and a final
delivered product.

This is an opportunity to make a reusable template. And to use numbers again.
Not as a unique identifier, but to control the order of filesystem folders.

Here's how their system might look. Area `10-19` is a standard Johnny.Decimal area, and they've expanded `20-29` to handle their clients and jobs.

<JDLineDiagram
  text={`
20-29 Clients and jobs
├──── Joe's Shoes
│     ├── Big Boots
│     │   ├── 2025-06-30 Box design
│     │   │   ├─── 10 Brief
│     │   │   ├─── 20 Copy
│     │   │   ├─── 30 Images
│     │   │   ├─── 40 Video
│     │   │   ├─── 50 Reviews
│     │   │   └─── 60 Final
│     │   ├── 2025-07-08 Full page ad
│     │   │   ├─── 10 Brief
│     │   │   ├─── 20 Copy
│     │   │   └─── …
│     │   └── 2025-08-11 ABC TV ad
│     │       └─── …
│     ├── Cool Kicks
│     │   └── 2025-06-30 …
│     └── Sick Sneakers
│         └── …
└──── Tammy's Trainers
        └── …
`}
  alt="A line drawing showing a Johnny.Decimal system. Area 20-29 is called clients and jobs. It contains two subfolders for our clients Joe's Shoes and Tammy's Trainers. Joe's Shoes then contains subfolders for their products, as noted in the text above. And then each product contains subfolders, numbered in tens starting with 10, for the brief, copy, images and so on."
  figNumber="62.27A"
  figCaption="A freelancer's templated system. It employs the principles: Use the alphabet, Use the date, Stop using numbers, Use natural hierarchies, Look for patterns."
/>

## Invent your own scheme

There's a reason people love their Johnny.Decimal IDs. They're a useful shortcut in many situations. So if you need an ID for something, feel free to make one up. Just remember: be consistent.

### Example: A freelancer

I like to give each of my invoices a unique ID that relates to the job.

In the example above, we might invent a scheme like `20.JOE.BB.20240708`. We're not going to use this code every day. But it serves as an unambiguous reference to that job when we need one.

And I shouldn't have to explain this scheme: it's obvious to which job I'm referring. Annotate your filesystem and JDex to make the scheme self-documenting.

<JDLineDiagram
  text={`
20-29 Clients and jobs
├──── Joe's Shoes (JOE)
│     ├──── Big Boots (BB)
│     │     └──── …
│     ├──── Cool Kicks (CK)
│     │     └──── …
│     └──── Sick Sneakers (SS)
│           └──── …
└──── Tammy's Trainers (TTR)
        └──── Chucks for Chicks (CC)
              └──── …
`}
  alt="A truncated version of the line drawing from above. After Joe's Shoes we now have (JOE). After Tammy's Trainers we have (TTR). After Big Boots, we have (BB), and similar abbreviations for the remaining products."
  figNumber="62.27B"
  figCaption="The freelancer's system annotated with codes for later use. Note the consistency: every client code is three letters; every product code is two."
/>

## Use existing codes

Much of life already uses the concept of a short code. University courses have them. Creative agencies use them. Almost every professional job management system will allocate a 'job number' of some kind. So where a code exists, don't invent another.

### Example: A student

Our student attends university in the Northern Hemisphere. They use the standard [Life Admin System](/las/) at `10-19`.

And they have a similar structure at `20-29` to handle the administration of being a student: finances, accommodation, and extra-curricular clubs. These are standard Johnny.Decimal areas.

Their courses require an expand-an-area solution. They naturally group by
year then semester, and each has a code assigned by the university. Within
each course, we use the same template, numbered from `10 … 60`.

It's convenient that the first semester, Autumn, sorts before Spring. If this
wasn't the case, we could add numbers to the front to force a sort. Perhaps
the month?

<JDLineDiagram
  text={`
10-19 Life admin
20-29 University admin
30-39 University courses
├──── 2024
│     ├── Autumn
│     │   ├── ENVE422
│     │   │   ├── 10 Course requirements
│     │   │   ├── 20 Course curriculum
│     │   │   ├── 30 Research & reading
│     │   │   ├── 40 Exam prep
│     │   │   ├── 50 Submissions
│     │   │   └── 60 Results
│     │   └── ENVE435
│     │       ├── 10 Course requirements
│     │       ├── 20 Course curriculum
│     │       └── …
│     └── Spring
│         ├── ENVE423
│         │   └── …
│         └── ENGS501
│             └── …
├──── 2025
│     ├── Autumn
│     │   ├── BIOL323
│     │   │   ├── 10 Course requirements
│     │   │   ├── 20 Course curriculum
│     │   │   └── …
│     │   └── PHIL666
│     │       └── …
│     └── Spring
│         └── …
└──── 2026
        └── …
`}
  alt="A line drawing showing our student's system as described above. We have areas, which contain years, which contain semesters, which contain classes, each of which has a template numbered in tens with course requirements, course curriculum, and so on."
  figNumber="62.27C"
  figCaption="A student's system with an expanded area for course work. Note the consistency: every year has two semesters; every semester has course codes; every course is templated."
/>