How our support engineers use Deep Search to investigate customer issues faster

Picture this: it's 3 PM on a Friday. A crucial customer reports authentication failures in production. The error is coming from a microservice you've never touched, built by a team in a different timezone. Documentation is outdated, and Slack searches lead nowhere.

Support has two choices:

1. Escalate and wait
2. Investigate the code directly using natural language

This is where Deep Search comes in. It lets Support Engineers (like me) ask questions about the codebase in plain language and receive structured, evidence-backed answers, including file paths, call flows, and recent code changes. Instead of searching blindly, support can understand how the system works, what changed, and what likely caused the failure.

How our support team uses Deep Search

Our internal support team regularly uses Deep Search to investigate when a customer reports an unexpected or confusing behaviour with the product, and we need to understand what the system is actually doing, not what the docs say it does.

A common starting point looks like this:

"Where is this error message generated, and what conditions trigger it?"

Deep Search doesn't just return files that contain the error string. It behaves more like a senior engineer dropped into the codebase:

• Searches across multiple repositories

• Follows call paths and references

• Reads relevant files end-to-end

• Looks at recent commits and behavior changes

• Synthesizes all of that into a clear explanation

Every answer shows the reasoning path, the files it read, and the searches it ran. Within minutes, support has enough context to either resolve the issue directly or escalate with a concrete, evidence-backed report that includes:

• Specific file locations

• Recent code changes

• Potential root causes

You can also conduct these searches without leaving your main workflow, as our Slack integration allows your team to investigate code issues directly within Slack.

The transformation: Before and after

Let's see how Deep Search changes the Friday afternoon crisis.

Traditional approach before Deep Search (~45–90 minutes)

1. Search for the error string across multiple repositories
2. Pasting errors to an agent lacking context makes understanding unfamiliar code difficult
3. Dig through commit history and old docs
4. Check internal tools for similar incidents
5. Escalate to engineering and wait

Outcome: Slow customer response. High escalation volume. Engineering interruptions. And even then, you might still not have the full picture.

With Deep Search (~5 minutes)

Prompt 1:

"Explain the payment processor state machine and what could cause an invalid transition from pending_verification to completed"

Answer (90 seconds):

Prompt 2:

****"Show me recent changes to the payment verification webhook handling"

Answer (60 seconds): "The commit a7f3c21 introduced a race condition bug in the webhook handling. See webhook_handler.go:89-112"

Prompt 3:

****"Are there any existing fixes for webhook race conditions in the payment system?"

Answer (75 seconds):"Yes, there's an idempotency key mechanism in payment_service.go:234 that prevents duplicate processing, but it's not enabled for verification webhooks. The configuration flag is ENABLE_WEBHOOK_IDEMPOTENCY"

Result: Complete understanding of the state machine, root cause identified, and a specific fix to recommend; all in under 5 minutes. No escalation needed.

For visual thinkers

If you're a support engineer who thinks visually, Deep Search can also generate Mermaid diagrams on demand. In this example, we asked Deep Search to produce a diagram showing how the services in the repository are connected, making the system architecture easier to understand at a glance.

When you have to escalate something, at least you're not going in blind. Deep Search tells you exactly where the problem lies in the codebase, so your escalation comes with real details rather than vague guesses.

The ROI: Stop escalating, start investigating

Investing in Deep Search isn't just a developer productivity boost. It's an investment in a code understanding platform that empowers your entire organization, acting as a force multiplier for support teams and developers alike.

For support teams:

• Fewer escalations to engineering

• Faster issue resolution (MTTR drops dramatically)

• Evidence-backed answers for customer communications

For engineering teams:

• Fewer interruptions

• Higher sprint velocity

• Better prepared escalations

Get started

Ready to transform your support operations? Experience Deep Search for yourself by taking a tour! For comprehensive information, including setup instructions and best practices, check out the official Deep Search docs.

About the author

Michael Bali is a Senior Support Engineer at Sourcegraph with over seven years of experience in technical support and customer success. He specializes in helping organizations troubleshoot complex code and infrastructure challenges, with a strong focus on improving support efficiency through code intelligence and AI-driven tooling.

---

A special thanks to the following individuals for their contributions to this blog post: Justin Dorfman, Graham McBain, and Stephanie Jarmak