Kafka troubleshooting, without the war room
Give engineers safe, self-service access to explore and fix Kafka issues – governed by the platform team, not routed through them.
Kafka troubleshooting is blocked by access bottlenecks
Issues can start anywhere: schema drift, config changes, quota limits; but developers need platform team approval to troubleshoot them. Every handoff is downtime.
Why observability tools aren’t enough
Infrastructure logs and metrics show system health, not the actual issue: bad schemas, malformed payloads, or misconfigured topics. Real Kafka troubleshooting means seeing the data itself.
Platform teams become the Kafka helpdesk
Every data access request becomes a ticket: retrieve a schema, check consumer lag, confirm a config. As Kafka adoption grows, your team spends more time answering questions than governing the platform.
Restricted Kafka access just goes underground
Locked-down Kafka is secure but unusable. Developers still need access, so they build in-house scripts and use unsupported tools – creating security gaps and technical debt.
Three issues that developers could have caught
Schema drift blocks releases
A schema changes in staging but not production, causing an incident after release.
With Lenses: Developers catch schema drift early by comparing staging and production schemas side-by-side in SQL Studio.
Poison pill messages cause consumer lag
A rogue producer publishes null values to a Kafka topic, causing consumer lag.
With Lenses: Get alerted to Kafka consumer lag, then query poison pill messages with SQL to find and remove them.
Quota misconfiguration slows Kafka throughput
App latency increases but the consumer looks healthy – the real issue is upstream.
With Lenses: Use Topology to map producer-to-consumer dependencies and spot which producer is throttled by an incorrectly set quota.
Safely open up streaming data to developers
Give engineers governed self-service access to discover and troubleshoot issues across every Kafka cluster.
Catch issues first
Developers spot schema drift, poison pills, and quota issues early.
Issues resolved by app owners
App teams triage and fix their own Kafka problems – no escalation needed.
Reduce Kafka MTTR
Developers access data without tickets, so time-to-resolution drops.
Focus on building, not firefighting
Fewer incidents means your teams stay focused on what matters.
Unlock platform team impact
Fewer tickets, same team size, more strategic capacity.
Kafka Troubleshooting features
Multi-Kafka global catalog
Topics, schemas, and data flows across all your Kafka clusters in one secure view.
Topology View
Visualize Kafka producer-to-consumer dependencies and consumer lag across your applications in real time.
SQL Studio
Query live Kafka topics with SQL syntax – no copying data elsewhere to explore.
Kafka monitoring & alerts
Monitor Kafka health with real-time alerts for latency, rate changes, and failures.
Governance and self-service
Enforce fine-grained access control and data masking based on your roles and permissions.
With an MCP Server
Connect AI agents to Kafka with scoped, short-lived OAuth tokens for safe operations.
What makes Lenses different?
Enterprise governance-first architecture
Powerful permission, data masking and auditing model build for enterprise environments
Vendor agnostic
Lenses works on top of any Kafka flavor including AWS MSK, Confluent, Aiven, and Apache Kafka setups.
No data movement
Query events with SQL syntax with data in its place; nothing is materialized in a separate store.
Scales to an enterprise footprint
Designed to scale to hundreds of clusters across different networks and distributions.
Fix problems before customers know they exist
"With how quickly our engineering teams build streaming apps, our systems proactively dispatch engineers and fix problems before customers even know there's an issue," Adam Astle, Head of Software Development at CityFibre.
Learn more
See a Kafka incident resolved - backwards
Lenses tracks and monitors all Consumer Groups connected to connected Kafka clusters to calculate offset-based and time-based lag into a unified monitoring view. Drilldowns are made available to instantly view the events for committed offsets using the Lenses SQL Studio. Alerts can be configured to be alerted when lag is detected.
A poison pill is a malformed message that stalls a consumer group instance. With Lenses SQL snapshot queries, developers can explore topics with SQL functions and conditional clauses to pinpoint the exact bad record, inspect its payload, and choose to skip or replay it - no blind consumer restarts or manual offset scrolling.
Yes. Lenses gives developers scoped, self-service access to only the topics, schemas and consumer groups they own - governed by RBAC, data policies and a full audit trail - so the platform team never gives up control.
Most time investigating incidents is lost waiting on the platform team who have enough visibility into Kafka, usually through tickets, escalations and war rooms. When app teams can investigate their own resources directly, incidents that took hours or days resolve in minutes - CityFibre cut service restoration from 3 days to 3 hours.
No. It complements them. Infrastructure observability tools tell you something at the broker or network level. Lenses tells you what’s wrong in at the “data layer” itself: the schema, the payload, the topic config and more, this sort of information simply isn’t available in Observability tools.
Yes, it’s common for customers to connect their AI Agent to Lenses via MCP and authorized via the OAuth 2.1 protocol. This allows a human to delegate access to Kafka to troubleshoot on their behalf with short-lived and scope credentials, backed by Lenses’ IAM model.
