From Chaos to Clarity: How Honeycomb Tags Are Transforming Developer Workflows

We're thrilled to announce that Honeycomb Tags are now generally available across SLOs, triggers, and boards! Over 100 customers are already actively tagging their observability resources in Honeycomb today.

The great resource hunt (and why it shouldn't exist)

It's 9:30 AM on a Tuesday, and Sarah's morning standup just ended with a familiar request: "Hey, can someone check if the payment service SLO is firing? I think we might have an issue with the checkout flow."

Sarah opens her observability tool… and stares at a wall filled with dozens of boards and SLOs. Some are hers, some belong to other teams, some are old experiments that should have been deleted months ago. She scrolls, squints at names, and starts the familiar dance of hunting through resources that could be better organized.

Sound familiar? We've all been there: that moment when you need to find that specific board or that critical SLO, but you're drowning in a sea of observability resources. As teams scale and observability becomes more central to daily workflows, the challenge of staying organized grows exponentially.

We heard this from our customers:

"Would like to see tagging and filtering capabilities in Honeycomb to better organize and manage these resources."

"Tagging w/ filters would work for organizing my resources by team."

"Tagging is the preferred solution to the resource organization problem."

The message was crystal clear: you needed a better way to organize, discover, and manage your growing collection of Honeycomb resources.

Why tags? Because you asked (and we listened)

When we set out to solve the resource organization challenge, we could have gone in different directions. But the feedback from our community was clear: tags were the way forward. Here's why:

Immediate impact: Tags get straight to the heart of the problem. No learning curve, no complex setup, just flexible key:value pairs that let you categorize resources exactly how your brain (and your team) thinks about them.

Familiar pattern: Tags are everywhere in the tools you already use. From AWS to GitHub to your favorite project management app, tags are the universal language of organization.

Flexible by design: Unlike rigid folder structures, tags let you slice and dice your resources in multiple ways. The same SLO can be tagged with team:payments, env:prod, and service:checkout, giving you multiple paths to discovery.

Built for scale: Unlike traditional monitoring platforms that impose cardinality limits or charge extra for high-dimensional data, Honeycomb tags are designed specifically for organizing observability resources without artificial constraints. You can tag without worrying about hitting limits or unexpected cost increases.

What tags unlock is the real story

Since launching tags, we've seen some patterns emerge within weeks from our customers:

• ~700 unique tags created
• ~8,000 resources tagged in total across SLOs, triggers, and boards
• 48% of tagged resources are triggers
• 37% of tagged resources are SLOs
• 15% of tagged resources are boards
• 25% of all tags use the team: key showing that team-based organization is the top priority

What caught our attention? Most customers are creating tags via API (74% vs 26% UI), which tells us this isn't just about convenience. Teams are building tags into their workflows and automation from day one.

Getting started: The essential three

Based on successful patterns we've observed across teams, here are the three essential tags to start with:

1. Team identity (team:<your-team-name>)

This is your north star tag. Most critical for resource discovery and access control. Examples: team:platform, team:checkout, team:data-eng

2. Service identification (service:<service-name>)

Technical component mapping that connects your observability to your architecture. Examples: service:api-gateway, service:user-auth, service:payments

2. Environment classification (env:<environment>)

Essential for operational safety and context. Values: prod, staging, dev, test

Back to Sarah's Tuesday morning

Remember Sarah from our opening story? Here's how her Tuesday morning looks now:

She opens her observability dashboard, clicks on SLOs, and filters by team:payments and service:checkout. Boom: there's the SLO she needs, along with three related ones she didn't even know existed but are probably worth checking too.

Total time spent hunting: 15 seconds. Time saved for actually investigating the issue: priceless.

What's next?

This GA launch is just the beginning. We're already seeing customers use tags in creative ways we hadn't anticipated, and we're building on that momentum. Here's what's coming:

• Expanded tag support across datasets
• Spaces, one pane of glass to see all tagged resources for a team or service
• Smart tag suggestions to help maintain consistency across teams
• Persistent tags to specify default tags that are pre-filtered when you return the UI

Ready to tag your way to clarity?

Tags are available right now across all Honeycomb plans. Whether you're managing a handful of SLOs or hundreds of observability resources across multiple teams, tags will transform how you organize and discover your work.

Head over to your SLOs, triggers, or boards and start adding those essential tags. Your future self (and your teammates) will thank you.