Skip to main content

​
1. Connect

Connect to your observability stack
Tero connects to your observability stack via API: Datadog, Splunk, your collectors, your pipelines. Read-only by default. No agents to deploy, no code changes, no infrastructure changes. Your setup stays exactly as it is.

​
2. Build context

Build context from your data
Tero analyzes your telemetry and builds context. Billions of raw logs compress into thousands of semantic log events. Each is understood: what it represents, when it matters, which service produces it. Services, dependencies, and failure scenarios get connected into a graph. This is the foundation. Not just a catalog of your data — a semantic understanding of what it means.

​
3. Review and approve rules

Review and approve rules
Tero analyzes the context and surfaces rules. Specific statements about what’s waste and why. Rules are organized by category: redundant attributes, health check logs, stray debugging, verbose payloads, repetitive events, PII leakage. Each category has a risk level. Start with the obvious: redundant fields that duplicate other fields, debug logs that shouldn’t be in production. These are zero-risk. You’ll agree immediately. As you build confidence, go deeper. Sampling high-volume events. Trimming verbose payloads. Categories that require more judgment. You can approve rules individually or entire categories at once. Automate what you’re confident in. Your ruleset grows over time.

​
4. Enforce

Approved rules get enforced. You choose where:

In your provider

Configure your provider
Configure exclusion filters, routing rules, or transformations directly via API. No deployment required. Fully reversible.
Fix it in your code
Open PRs to fix instrumentation at the source. Or create tickets for engineers to handle on their schedule.
Execute at the edge
Execute rules at the edge before data leaves your network. Drop-in replacements for collectors you already run. Same config, new capabilities.
Rules stay enforced. Tero monitors for regression. If a problem resurfaces — an engineer re-enables debug logging, a new service emits the same waste pattern — Tero catches it. New rules surface as your systems evolve. You review incrementally. Your ruleset grows. Problems you fix stay fixed.