Taxonomy Example
Building Your Product Taxonomy — Example & Best Practices
Your product taxonomy is a structured hierarchy that BuildBetter uses to automatically categorize signals from calls, feedback, and other sources. A well-built taxonomy ensures every piece of customer feedback gets routed to the right product area — so nothing falls through the cracks.
How it works
- Paste your product documentation (feature lists, help docs, marketing pages, release notes) into the taxonomy generator
- AI extracts a 4-level hierarchy from your documentation
- Signals get auto-labeled against your taxonomy as they come in
The 4-level hierarchy
| Level | Purpose | Example |
|---|---|---|
| Domain | High-level product area or customer journey | "Collaboration" |
| Product | A specific offering, module, or major feature set | "Real-Time Documents" |
| Feature | A capability or functionality within a product | "Comments & Threads" |
| Tag | A specific scenario, variation, or label to apply | "Inline comments", "Unresolved threads" |
Domains organize your product at the highest level. Products are the modules within each domain. Features are the things users actually interact with. Tags are the specific labels AI applies to signals.
Note: Only Product, Feature, and Tag levels are auto-labeled. Domains provide organizational context but are not directly applied to signals.
Example: Project management platform
Below is a complete taxonomy for a fictional project management tool called "ProjectFlow." This is the kind of document you'd paste into the taxonomy generator.
Input document
ProjectFlow Product Documentation
==================================
WORK MANAGEMENT
---------------
Task Boards
TaskFlow is our core task management module. Users create tasks on
kanban boards with customizable columns (To Do, In Progress, Review, Done).
Features:
- Task creation: Create tasks with title, description, assignee, due date,
priority (P0-P3), and story points. Supports bulk creation via CSV import.
- Board views: Kanban, list, calendar, and timeline (Gantt) views.
Users can save custom views with filters.
- Automations: Rule-based automations triggered by status changes,
due dates, or field updates. Supports "when-then" rules
(e.g., "when status changes to Done, notify channel").
- Custom fields: Text, number, dropdown, date, and people field types.
Org admins can create shared custom fields.
- Dependencies: Finish-to-start, start-to-start, and blocking dependency
types. Dependency visualization on timeline view.
Sprints & Roadmaps
Sprint planning module for agile teams. Supports 1-4 week sprint cycles.
Features:
- Sprint planning: Drag tasks from backlog into sprints.
Capacity planning based on story points and assignee availability.
- Velocity tracking: Burndown charts, velocity over time,
and sprint completion rate metrics.
- Roadmap: Quarter-based roadmap view. Tracks initiatives
(groups of tasks) against milestones.
- Backlog grooming: Priority-ranked backlog with inline estimation.
Supports planning poker for team estimation.
COLLABORATION
-------------
Documents
Real-time collaborative documents with rich text editing (Markdown, tables,
embeds). Documents live inside projects or as standalone pages.
Features:
- Editor: Block-based editor supporting headings, lists, code blocks,
tables, images, and embeds (Figma, Loom, YouTube).
- Comments & threads: Inline comments on any text selection.
Comment threads can be resolved or reopened. @mentions notify users.
- Templates: Organization-wide document templates for PRDs, meeting notes,
retrospectives, and RFCs.
- Version history: Full version history with named versions.
Compare any two versions side-by-side.
Messaging
Built-in team messaging with channels and direct messages.
Features:
- Channels: Public and private channels organized by project or topic.
Channel-level notification preferences.
- Direct messages: 1:1 and group DMs. Supports message editing
and deletion within 15-minute window.
- Threads: Reply threads on any message. Thread followers get
notifications for new replies.
- Search: Full-text message search with filters for sender,
channel, date range, and has:attachment/link.
INTEGRATIONS & PLATFORM
------------------------
Integrations
Connect ProjectFlow with your existing tools.
Supported integrations:
- Slack: Two-way sync — create tasks from Slack messages,
get notifications in Slack channels. Supports slash commands.
- GitHub: Link PRs to tasks, auto-update task status on merge.
Branch name convention: PF-{task-id}-{description}.
- Figma: Embed Figma frames in documents, link designs to tasks.
- Jira: Two-way import/sync for teams migrating from Jira.
Field mapping configuration during setup.
API & Webhooks
RESTful API with OAuth 2.0 authentication. Rate limit: 100 req/min
for standard plans, 500 req/min for Enterprise.
Features:
- REST API: Full CRUD for tasks, projects, documents, and users.
Supports bulk operations and pagination.
- Webhooks: Event-driven notifications for task.created, task.updated,
task.status_changed, comment.created, and 20+ other events.
Webhook signature verification via HMAC-SHA256.
- OAuth apps: Build and publish apps to the ProjectFlow marketplace.
OAuth scopes: read:tasks, write:tasks, read:projects, admin:org.
ADMIN & SECURITY
-----------------
Organization Management
Tools for org admins to manage users, teams, and settings.
Features:
- User management: Invite via email or SSO provisioning (SCIM).
Roles: Owner, Admin, Member, Guest. Custom roles on Enterprise plan.
- Teams: Group users into teams with shared permissions.
Team-level project access and notification settings.
- Audit log: Immutable audit log of all admin actions, login events,
and data exports. Filterable by actor, action type, and date range.
Retention: 1 year (standard), unlimited (Enterprise).
Security
Enterprise-grade security features.
Features:
- SSO/SAML: SAML 2.0 SSO with support for Okta, Azure AD, Google Workspace,
and OneLogin. JIT provisioning and SCIM directory sync.
- Data residency: Choose between US, EU, and APAC data regions during setup.
Migration between regions available upon request.
- Encryption: AES-256 at rest, TLS 1.3 in transit. Customer-managed
encryption keys (CMEK) on Enterprise plan.
- Compliance: SOC 2 Type II, GDPR, HIPAA (BAA available).
Annual penetration testing by third-party firm.
Generated taxonomy
Here's what the AI produces from the above input — shown as the tree view you'll see in BuildBetter's settings:
Work Management
Task Boards
Task Creation
Task fields
Bulk import
Board Views
Kanban view
Timeline / Gantt
Calendar view
Custom saved views
Automations
When-then rules
Status change triggers
Custom Fields
Field types
Shared org fields
Dependencies
Dependency types
Dependency visualization
Sprints & Roadmaps
Sprint Planning
Capacity planning
Backlog to sprint
Velocity Tracking
Burndown charts
Sprint metrics
Roadmap
Initiatives & milestones
Backlog Grooming
Priority ranking
Estimation
Collaboration
Documents
Editor
Rich text blocks
Embeds
Comments & Threads
Inline comments
Thread resolution
Mentions
Templates
Template management
Version History
Version comparison
Named versions
Messaging
Channels
Channel management
Channel notifications
Direct Messages
Group DMs
Message editing
Threads
Reply threads
Search
Message search
Integrations & Platform
Integrations
Slack Integration
Slack two-way sync
Slash commands
GitHub Integration
PR linking
Branch conventions
Figma Integration
Design embeds
Jira Migration
Jira import/sync
API & Webhooks
REST API
API operations
Rate limits
Webhooks
Webhook events
Webhook security
OAuth Apps
Marketplace apps
OAuth scopes
Admin & Security
Organization Management
User Management
Invites & provisioning
Roles & permissions
Teams
Team permissions
Audit Log
Audit log access
Audit retention
Security
SSO / SAML
SSO providers
SCIM directory sync
Data Residency
Region selection
Encryption
Encryption standards
Customer-managed keys
Compliance
Compliance certifications
What makes this taxonomy effective
1. Domains reflect how customers think, not how your org is structured
"Work Management" and "Collaboration" map to customer jobs-to-be-done, not internal team names like "Core Platform Team" or "Growth Squad."
2. Products are distinct modules with clear boundaries
Each product (Task Boards, Documents, Messaging) is something a customer would recognize as a separate thing. Avoid overlapping products — if two products share features, pick the primary home.
3. Features are specific and actionable
"Comments & Threads" is better than "Social Features." "Sprint Planning" is better than "Agile." Name features the way your customers and your docs name them.
4. Tags have clear instructions
Every tag includes an instructions field that tells the AI exactly when to apply it. This is the most important part — vague instructions lead to inaccurate labeling.
Good instruction: "Apply when the signal mentions creating tasks from Slack or receiving Slack notifications"
Bad instruction: "Apply when related to Slack"
5. Tags capture specific scenarios, not duplicates of the feature name
Tags should represent variations, use cases, or specific aspects — not just restate the feature. If a feature only has one scenario, one tag is fine.
Tips for writing input documentation
The quality of your taxonomy depends on the quality of the text you provide. Here's what to include:
| Include | Why |
|---|---|
| Feature lists with descriptions | Gives the AI clear feature names and boundaries |
| Specific names (integrations, tools, standards) | Preserves exact terminology as tags |
| Technical details (limits, config options, specs) | Creates specific, actionable tags |
| User workflows and scenarios | Helps the AI understand when to apply each tag |
| Edge cases and error conditions | Creates tags for support-related signals |
Best sources to paste in:
- Help center articles or knowledge base
- Feature comparison pages
- Release notes (last 6-12 months)
- Product marketing pages
- API documentation overviews
- Security/compliance pages
Avoid:
- Internal jargon customers wouldn't use
- Org charts or team structures (these aren't product areas)
- Extremely long documents with redundant content (the generator has a 100K character limit)
After generation: refine and iterate
The generated taxonomy is a starting point. After generation:
- Review the tree in Settings > Features > AI Labeling — rename or remove anything that doesn't match your product vocabulary
- Add missing tags for common support scenarios the docs didn't cover
- Edit tag instructions to be more specific to your customer base
- Re-generate anytime your product significantly changes — paste updated docs and the taxonomy will be replaced with a fresh structure