Skip to main content

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

  1. Paste your product documentation (feature lists, help docs, marketing pages, release notes) into the taxonomy generator
  2. AI extracts a 4-level hierarchy from your documentation
  3. Signals get auto-labeled against your taxonomy as they come in

The 4-level hierarchy

LevelPurposeExample
DomainHigh-level product area or customer journey”Collaboration”
ProductA specific offering, module, or major feature set”Real-Time Documents”
FeatureA capability or functionality within a product”Comments & Threads”
TagA 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.
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:
IncludeWhy
Feature lists with descriptionsGives 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 scenariosHelps the AI understand when to apply each tag
Edge cases and error conditionsCreates 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:
  1. Review the tree in Settings > AI Labeling — rename or remove anything that doesn’t match your product vocabulary
  2. Add missing tags for common support scenarios the docs didn’t cover
  3. Edit tag instructions to be more specific to your customer base
  4. Re-generate anytime your product significantly changes — paste updated docs and the taxonomy will be replaced with a fresh structure