Main: Navigate the Platform with Confidence
Published · Updated
Main navigation should help a user understand where they are, what they can do next, and how to reach the most important parts of the platform without losing context. This guide explains hierarchy, labels, search, project switching, contextual navigation, shortcuts, mobile behavior, accessibility, and structure so navigation remains predictable as the product grows.
Build a clear navigation hierarchy
Build a clear navigation hierarchy should begin with a clear user goal and a description of the current state. Define what the user is trying to accomplish, what information or interface is available, what action begins the path, and what result should be visible at completion. In main navigation design, this turns a broad design or building idea into a concrete workflow that can be tested instead of a collection of attractive but disconnected choices.
Evaluate Build a clear navigation hierarchy with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not document an exact launch time, mobile publishing feature, visual-editor control, template inventory, or platform behavior, explain the general method instead of inventing details. This keeps the guide practical and faithful to the source.
Ownership around Build a clear navigation hierarchy should remain explicit. Teams need to know who prepares the content or configuration, who reviews the result, who handles exceptions, and who approves a change that affects users or production. A lightweight checklist, preview, test result, or review record is often enough. The purpose is continuity: another person should be able to understand the current decision and safely continue the work without private context.
As the project grows, retest Build a clear navigation hierarchy with more users, pages, screens, devices, content, data, and workflows. Look for stale assumptions, duplicate paths, ambiguous labels, missing validation, inaccessible behavior, weak responsive design, hidden dependencies, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses observed behavior to guide the next improvement.
- Define the expected result
- Record the evidence
- Test the edge case
- Assign clear ownership
Use labels users can predict
Use labels users can predict should begin with a clear user goal and a description of the current state. Define what the user is trying to accomplish, what information or interface is available, what action begins the path, and what result should be visible at completion. In main navigation design, this turns a broad design or building idea into a concrete workflow that can be tested instead of a collection of attractive but disconnected choices.
Evaluate Use labels users can predict with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not document an exact launch time, mobile publishing feature, visual-editor control, template inventory, or platform behavior, explain the general method instead of inventing details. This keeps the guide practical and faithful to the source.
Ownership around Use labels users can predict should remain explicit. Teams need to know who prepares the content or configuration, who reviews the result, who handles exceptions, and who approves a change that affects users or production. A lightweight checklist, preview, test result, or review record is often enough. The purpose is continuity: another person should be able to understand the current decision and safely continue the work without private context.
As the project grows, retest Use labels users can predict with more users, pages, screens, devices, content, data, and workflows. Look for stale assumptions, duplicate paths, ambiguous labels, missing validation, inaccessible behavior, weak responsive design, hidden dependencies, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses observed behavior to guide the next improvement.
- Define the expected result
- Record the evidence
- Test the edge case
- Assign clear ownership
Keep search easy to reach
Keep search easy to reach should begin with a clear user goal and a description of the current state. Define what the user is trying to accomplish, what information or interface is available, what action begins the path, and what result should be visible at completion. In main navigation design, this turns a broad design or building idea into a concrete workflow that can be tested instead of a collection of attractive but disconnected choices.
Evaluate Keep search easy to reach with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not document an exact launch time, mobile publishing feature, visual-editor control, template inventory, or platform behavior, explain the general method instead of inventing details. This keeps the guide practical and faithful to the source.
Ownership around Keep search easy to reach should remain explicit. Teams need to know who prepares the content or configuration, who reviews the result, who handles exceptions, and who approves a change that affects users or production. A lightweight checklist, preview, test result, or review record is often enough. The purpose is continuity: another person should be able to understand the current decision and safely continue the work without private context.
As the project grows, retest Keep search easy to reach with more users, pages, screens, devices, content, data, and workflows. Look for stale assumptions, duplicate paths, ambiguous labels, missing validation, inaccessible behavior, weak responsive design, hidden dependencies, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses observed behavior to guide the next improvement.
- Define the expected result
- Record the evidence
- Test the edge case
- Assign clear ownership
Preserve context while switching projects
Preserve context while switching projects should begin with a clear user goal and a description of the current state. Define what the user is trying to accomplish, what information or interface is available, what action begins the path, and what result should be visible at completion. In main navigation design, this turns a broad design or building idea into a concrete workflow that can be tested instead of a collection of attractive but disconnected choices.
Evaluate Preserve context while switching projects with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not document an exact launch time, mobile publishing feature, visual-editor control, template inventory, or platform behavior, explain the general method instead of inventing details. This keeps the guide practical and faithful to the source.
Ownership around Preserve context while switching projects should remain explicit. Teams need to know who prepares the content or configuration, who reviews the result, who handles exceptions, and who approves a change that affects users or production. A lightweight checklist, preview, test result, or review record is often enough. The purpose is continuity: another person should be able to understand the current decision and safely continue the work without private context.
As the project grows, retest Preserve context while switching projects with more users, pages, screens, devices, content, data, and workflows. Look for stale assumptions, duplicate paths, ambiguous labels, missing validation, inaccessible behavior, weak responsive design, hidden dependencies, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses observed behavior to guide the next improvement.
- Define the expected result
- Record the evidence
- Test the edge case
- Assign clear ownership
Use contextual navigation carefully
Use contextual navigation carefully should begin with a clear user goal and a description of the current state. Define what the user is trying to accomplish, what information or interface is available, what action begins the path, and what result should be visible at completion. In main navigation design, this turns a broad design or building idea into a concrete workflow that can be tested instead of a collection of attractive but disconnected choices.
Evaluate Use contextual navigation carefully with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not document an exact launch time, mobile publishing feature, visual-editor control, template inventory, or platform behavior, explain the general method instead of inventing details. This keeps the guide practical and faithful to the source.
Ownership around Use contextual navigation carefully should remain explicit. Teams need to know who prepares the content or configuration, who reviews the result, who handles exceptions, and who approves a change that affects users or production. A lightweight checklist, preview, test result, or review record is often enough. The purpose is continuity: another person should be able to understand the current decision and safely continue the work without private context.
As the project grows, retest Use contextual navigation carefully with more users, pages, screens, devices, content, data, and workflows. Look for stale assumptions, duplicate paths, ambiguous labels, missing validation, inaccessible behavior, weak responsive design, hidden dependencies, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses observed behavior to guide the next improvement.
- Define the expected result
- Record the evidence
- Test the edge case
- Assign clear ownership
Support keyboard and shortcut navigation
Support keyboard and shortcut navigation should begin with a clear user goal and a description of the current state. Define what the user is trying to accomplish, what information or interface is available, what action begins the path, and what result should be visible at completion. In main navigation design, this turns a broad design or building idea into a concrete workflow that can be tested instead of a collection of attractive but disconnected choices.
Evaluate Support keyboard and shortcut navigation with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not document an exact launch time, mobile publishing feature, visual-editor control, template inventory, or platform behavior, explain the general method instead of inventing details. This keeps the guide practical and faithful to the source.
Ownership around Support keyboard and shortcut navigation should remain explicit. Teams need to know who prepares the content or configuration, who reviews the result, who handles exceptions, and who approves a change that affects users or production. A lightweight checklist, preview, test result, or review record is often enough. The purpose is continuity: another person should be able to understand the current decision and safely continue the work without private context.
As the project grows, retest Support keyboard and shortcut navigation with more users, pages, screens, devices, content, data, and workflows. Look for stale assumptions, duplicate paths, ambiguous labels, missing validation, inaccessible behavior, weak responsive design, hidden dependencies, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses observed behavior to guide the next improvement.
- Define the expected result
- Record the evidence
- Test the edge case
- Assign clear ownership
Design mobile navigation deliberately
Design mobile navigation deliberately should begin with a clear user goal and a description of the current state. Define what the user is trying to accomplish, what information or interface is available, what action begins the path, and what result should be visible at completion. In main navigation design, this turns a broad design or building idea into a concrete workflow that can be tested instead of a collection of attractive but disconnected choices.
Evaluate Design mobile navigation deliberately with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not document an exact launch time, mobile publishing feature, visual-editor control, template inventory, or platform behavior, explain the general method instead of inventing details. This keeps the guide practical and faithful to the source.
Ownership around Design mobile navigation deliberately should remain explicit. Teams need to know who prepares the content or configuration, who reviews the result, who handles exceptions, and who approves a change that affects users or production. A lightweight checklist, preview, test result, or review record is often enough. The purpose is continuity: another person should be able to understand the current decision and safely continue the work without private context.
As the project grows, retest Design mobile navigation deliberately with more users, pages, screens, devices, content, data, and workflows. Look for stale assumptions, duplicate paths, ambiguous labels, missing validation, inaccessible behavior, weak responsive design, hidden dependencies, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses observed behavior to guide the next improvement.
- Define the expected result
- Record the evidence
- Test the edge case
- Assign clear ownership
Test accessibility and wayfinding
Test accessibility and wayfinding should begin with a clear user goal and a description of the current state. Define what the user is trying to accomplish, what information or interface is available, what action begins the path, and what result should be visible at completion. In main navigation design, this turns a broad design or building idea into a concrete workflow that can be tested instead of a collection of attractive but disconnected choices.
Evaluate Test accessibility and wayfinding with a normal case, an incomplete case, an edge case, and a failure. Record the input, expected behavior, owner, dependency, and evidence that confirms success or recovery. If the source does not document an exact launch time, mobile publishing feature, visual-editor control, template inventory, or platform behavior, explain the general method instead of inventing details. This keeps the guide practical and faithful to the source.
Ownership around Test accessibility and wayfinding should remain explicit. Teams need to know who prepares the content or configuration, who reviews the result, who handles exceptions, and who approves a change that affects users or production. A lightweight checklist, preview, test result, or review record is often enough. The purpose is continuity: another person should be able to understand the current decision and safely continue the work without private context.
As the project grows, retest Test accessibility and wayfinding with more users, pages, screens, devices, content, data, and workflows. Look for stale assumptions, duplicate paths, ambiguous labels, missing validation, inaccessible behavior, weak responsive design, hidden dependencies, and changes that are difficult to reverse. Strong design keeps the critical path understandable and uses observed behavior to guide the next improvement.
- Define the expected result
- Record the evidence
- Test the edge case
- Assign clear ownership
Questions
What should I verify first?
Start with the user goal, current structure, owner, dependencies, and a clear definition of success.
Should I assume undocumented launch or mobile features?
No. Keep source-backed facts separate from general design guidance and mark unknowns clearly.
How should I test the result?
Use realistic tasks, real devices or viewport sizes where relevant, and evidence that the core user path works.
When should the guide be updated?
Update it after meaningful changes to navigation, templates, mobile behavior, visual editing, publishing, or platform structure.