Systems Design Case Study
I needed a knowledge-management system that matched how I naturally collect and retrieve information, so I designed one around my actual behavior instead of forcing myself into a generic workflow.
Role: Systems designer and initial user
Focus: Information architecture, workflow design, automation, documentation, privacy, and maintainability
Platform: Tana
Status: Private working system refined through continued use
1. Overview
Tana Organization is a private personal knowledge-management system. It is not a standalone application, and this case study is not a tutorial about configuring Tana.
The project demonstrates how I approached an everyday organizational problem as a systems-design challenge. I observed how I actually captured and looked for information, identified recurring points of friction, translated those observations into requirements, and designed a system around them. I then refined the design through real use.
The result is a structured path from quick capture to useful knowledge and action:
Capture → Processing Queue → Classification → Connected Knowledge → Action or Retrieval
This public case study describes the design reasoning and workflow without exposing the private information stored in the system.
2. The problem
Conventional organization methods often expected me to decide where information belonged at the moment I encountered it. That created friction at exactly the wrong time: while I was trying to record an idea, remember a commitment, preserve a useful reference, or move on to the next task.
Several recurring problems emerged:
- Capture became slower when every item required an immediate filing decision.
- Rigid folder structures forced information into a single category even when it related to several areas.
- Inconsistent naming and placement made later retrieval depend too heavily on memory.
- Notes, tasks, references, and developing ideas could become mixed together without a clear processing step.
- A system could be carefully organized yet still fail if maintaining it required too much effort.
The real problem was therefore not simply “where should I store notes?” It was:
How can a knowledge system accept information quickly, help me make sense of it later, preserve useful connections, and make the result easy to act on or retrieve?
3. Behavioral observations
Because I was both the designer and the initial user, I treated my own repeated behavior as user-research evidence. I paid attention to what happened during capture, processing, and retrieval rather than beginning with an idealized organization chart.
Capture behavior
- I needed to record information before its final category was always clear.
- Interrupting capture to make several metadata decisions increased the chance that I would postpone or abandon it.
- Different inputs could represent different future needs: an idea, a task, a reference, a person, a project, or something still unknown.
Organization behavior
- One piece of information could be relevant to multiple contexts.
- Connections were often more useful than a single permanent location.
- Classification worked better as a deliberate processing activity than as a requirement for initial capture.
- The system needed enough structure to remain dependable without requiring constant reorganization.
Retrieval behavior
- I did not always remember an exact title or storage location.
- I was more likely to remember a related project, person, topic, event, or intended action.
- Useful retrieval required multiple paths: search, relationships, views, and context.
- Information was most valuable when it could resurface at the moment of action.
These observations changed the design goal. Instead of building the most detailed hierarchy possible, I needed to build a reliable flow that matched the way information naturally entered and left the system.
4. Requirements and constraints
I translated the behavioral observations into practical requirements.
| Requirement | Design response |
|---|---|
| Capture must be fast | Allow incomplete items to enter through a low-friction capture point. |
| Classification should not interrupt thinking | Separate initial capture from later processing. |
| Information may belong to several contexts | Use relationships and attributes instead of relying only on folders. |
| Unprocessed material must remain visible | Route new items into a processing queue rather than an invisible archive. |
| Retrieval cannot depend on exact memory | Support multiple retrieval paths through context, connection, and search. |
| Knowledge should support action | Distinguish actionable items from references and connect them where useful. |
| The system must survive real use | Keep required fields and maintenance steps purposeful and limited. |
| Private information must remain private | Exclude sensitive content from public examples and manage access and credentials separately. |
Additional constraints shaped the system:
- I was designing for a real, changing set of needs rather than a fixed demonstration dataset.
- The architecture needed to accommodate uncertainty during capture.
- Automations could assist the workflow but could not become a hidden dependency that made the system hard to understand.
- Synchronization and access had to be considered without exposing private workspace details.
- Documentation needed to make future maintenance possible, including for a version of me who no longer remembered every design decision.
5. System and information architecture
The architecture separates the state of information from the subject of information.
An item can move through states such as captured, awaiting review, classified, connected, actionable, or retained for retrieval. Its subject can independently relate to a project, area, person, topic, resource, or another relevant context.
INPUTS
Quick notes · ideas · commitments · references · observations
│
▼
CAPTURE LAYER
One low-friction entry point; incomplete information is allowed
│
▼
PROCESSING LAYER
Clarify meaning · decide whether it matters · identify next state
│ │
▼ ▼
STRUCTURE LAYER ACTION LAYER
Types · attributes · relationships Tasks · follow-ups · decisions
│ │
└──────────┬──────────────┘
▼
RETRIEVAL LAYER
Search · contextual views · linked records · project or topic entry points
This model avoids treating every note as the same kind of object. It also avoids requiring the final structure to be known at the first moment of capture.
Core architectural principles
- Capture first, decide later. Uncertainty is an expected input state.
- Use structure where it improves retrieval or action. Metadata must earn its maintenance cost.
- Connect information across contexts. Relationships reduce the limitations of a single filing location.
- Make unfinished processing visible. A queue turns ambiguity into a manageable workflow.
- Preserve a clear route out of the system. Information should lead to action, informed decisions, or dependable retrieval.
6. Workflow
Step 1: Capture
Information enters through a quick, forgiving capture point. The goal is to preserve meaning with minimal interruption. A captured item may initially contain only a short phrase and enough context to recognize it later.
Fabricated example:
“Compare accessibility testing tools mentioned during portfolio research.”
Step 2: Processing queue
New items enter a visible queue. During processing, I ask:
- What is this?
- Does it require action?
- Is it useful as reference material?
- What context will help me find it again?
- Should it be connected to an existing project, topic, or person?
- Can it be deleted instead of organized?
Step 3: Classification
The item receives only the structure needed for its purpose. For example, the fabricated note might become a research item associated with a portfolio project and an accessibility-testing topic.
Classification is not the finish line. It is a decision about how the item should behave in the system.
Step 4: Connected knowledge
The item is connected to relevant contexts. These connections create several possible retrieval routes without requiring duplicate copies.
Fabricated research item
├── Portfolio project
├── Accessibility testing
├── Tool comparison
└── Possible learning task
Step 5: Action or retrieval
If the information requires action, it can generate or support a task, follow-up, or decision. If it is reference material, it remains available through search and contextual views.
The workflow is complete when the information has a clear role—not merely when it has been stored.
7. Key decisions and tradeoffs
Delayed classification vs. immediate organization
Decision: Permit rapid capture and classify later.
Benefit: Capture remains fast and tolerant of uncertainty.
Tradeoff: The processing queue must be reviewed consistently or it becomes a new form of clutter.
Relationships vs. deep folder hierarchies
Decision: Emphasize connections and contextual attributes.
Benefit: The same information can appear in several meaningful contexts without duplication.
Tradeoff: Relationship design requires clear naming and restraint. Too many relationship types can make the system harder to understand.
Structured records vs. free-form notes
Decision: Use structure for information that benefits from predictable behavior while preserving space for free-form thinking.
Benefit: Structured information can support views, retrieval, and automation.
Tradeoff: Excessive structure increases capture and maintenance costs.
Automation vs. transparency
Decision: Automate repeatable routing or formatting only when the behavior remains understandable and recoverable.
Benefit: Automation can reduce repetitive work and improve consistency.
Tradeoff: Hidden or overly complex automation makes troubleshooting and future maintenance more difficult.
Personal fit vs. universal design
Decision: Optimize the initial system for observed personal behavior.
Benefit: The workflow solves a real problem for a real user.
Tradeoff: A system designed for one user should not be presented as universally correct. Supporting other users would require additional research and validation.
8. Iterations
The architecture evolved through use rather than being completed in one design pass.
Use the system
↓
Notice repeated friction or confusion
↓
Identify the underlying behavior
↓
Adjust a rule, relationship, view, or automation
↓
Document the decision
↓
Observe the result during continued use
Examples of the kinds of refinements this process supports include:
- reducing required metadata when capture feels too slow;
- clarifying categories that repeatedly overlap;
- changing views when useful information does not resurface;
- simplifying automation that is difficult to diagnose;
- improving documentation when a workflow is easy to forget;
- removing structures that add maintenance without improving retrieval.
This approach treats friction as design feedback. It also prevents the system from becoming a static model of how I once expected myself to work.
9. Outcomes
The project produced a working personal knowledge system organized around an explicit information lifecycle rather than a collection of disconnected notes.
Its most important outcome is not the number of configurations or automations created. It is the translation of observed behavior into a coherent system:
- Rapid capture is separated from deliberate processing.
- Unclassified information has a visible temporary state.
- Connections provide several routes back to useful knowledge.
- Actionable information can move toward tasks and decisions.
- Documentation records how and why the system works.
- Privacy boundaries define what remains private and what can be shown publicly.
Because this is a personal system, I am not presenting controlled performance measurements or claiming that the design has been validated for other users. The evidence is the functioning workflow, the documented design decisions, and the refinements made through continued use.
10. Lessons learned
Design for observed behavior
A workflow is more sustainable when it reflects what a user repeatedly does, including moments of uncertainty, rather than what an ideal process assumes they will do.
Separate capture from processing
Combining these activities can make both harder. Separating them preserves speed while still creating a path toward structure.
Structure has a cost
Every field, category, relationship, and automation creates future maintenance. The right amount of structure is the amount that improves retrieval, understanding, or action.
Retrieval is part of information architecture
Storing information successfully is not enough. A useful design anticipates the different clues a person may remember later.
Iteration requires documentation
Without a record of decisions, a personal system can become dependent on memory. Documentation makes the architecture easier to maintain, evaluate, and change.
Privacy is a design responsibility
A compelling portfolio story does not require exposing the underlying personal data. Fabricated examples and architectural explanations can demonstrate judgment while preserving confidentiality.
Privacy and maintainability
The working system contains private personal information, so the public portfolio version is intentionally separated from it.
- No personal notes or private Tana content
- No workspace names, node identifiers, internal links, or correspondence
- No tokens, credentials, environment files, or authentication details
- No machine-specific paths or synchronization details
- No screenshots unless they are recreated, fabricated, or thoroughly sanitized
All examples on this page are generic and fabricated. Credentials belong in appropriate secret-management systems, synchronization must be verified rather than assumed, and automations should have documented purposes and understandable failure states.
Transferable professional skills
- Systems thinking: designing an end-to-end information lifecycle rather than isolated features
- Information architecture: defining states, relationships, contexts, and retrieval paths
- User-centered design: deriving requirements from observed behavior
- Workflow design: moving information from input through decisions to useful outcomes
- Automation judgment: balancing efficiency with transparency and maintainability
- Iterative problem-solving: using recurring friction as evidence for refinement
- Documentation: recording processes, decisions, constraints, and safe operating boundaries
- Privacy awareness: separating private source material from public demonstrations