This is a submission for the GitHub Finish-Up-A-Thon Challenge
What I Built
DebugProbe.AspNetCore is an ASP.NET Core debugging and API comparison tool designed to help developers understand exactly how their applications behave across different environments.
It captures incoming requests, outgoing HTTP calls, headers, bodies, timings, exceptions, and middleware execution details through a lightweight web interface.
What makes the project different is its focus on API comparison.
Instead of manually inspecting logs from multiple environments, developers can compare requests side-by-side and quickly identify differences in responses, headers, payloads, status codes, and behavior.
The goal is simple:
Reduce the time required to answer one of the most common debugging questions:
"Why does this work in one environment but not in another?"
The project started as a personal tool because I was tired of manually comparing logs, requests, and responses when debugging production issues. Over time it evolved into a reusable open-source solution for ASP.NET Core developers.
Demo
Live Demo
Demo API
Links
- Website: https://debugprobe.dev
- Documentation: https://debugprobe.dev/docs
- NuGet Package: https://www.nuget.org/packages/DebugProbe.AspNetCore
- Repository: https://github.com/DebugProbe/DebugProbe.AspNetCore
- Roadmap: https://github.com/DebugProbe/DebugProbe.AspNetCore/blob/main/Roadmap.md
Screenshots
Review Captured HTTP Traffic
Inspect Complete Request & Response Details
Compare API Behavior Across Environments
The Comeback Story
DebugProbe.AspNetCore started as a simple debugging experiment.
My original goal was straightforward: create a lightweight way to inspect requests and responses inside ASP.NET Core applications without relying on external tools.
The first versions worked, but over time I realized something important.
The debugging information itself was useful, but the most valuable part was comparing behavior.
Many production issues are not caused by obvious exceptions. They happen because an API behaves slightly differently between local development, staging, and production.
- Different headers
- Different payloads
- Different status codes
- Different downstream service responses
Developers often spend hours comparing logs manually to find these differences.
That realization changed the direction of the project.
Instead of building another request inspector, I started focusing on comparison workflows.
Over time the project evolved with:
- Request and response inspection
- API comparison capabilities
- Outbound HttpClient tracing
- Improved filtering and navigation
- Better UI and usability
- Documentation and examples
- Live demo environment
- Organized GitHub workflows
- Continuous improvements based on community feedback
What began as a small debugging utility gradually became a more complete developer tool focused on understanding application behavior.
Today, DebugProbe.AspNetCore is a stable open-source project at version 1.6.0, with documentation, a live demo, regular releases, and a growing roadmap.
My Experience with GitHub Copilot
I primarily built DebugProbe.AspNetCore myself, while GitHub helped me organize the project through issues, pull requests, releases, discussions, and overall project management.
One lesson I learned while working on this project is that building the software is only part of the job.
Maintaining documentation, organizing issues, planning future work, tracking releases, and communicating project direction are all important parts of turning a repository into a real open-source project.
GitHub became the place where the project evolved from a collection of features into something more structured and maintainable.
This challenge gave me a chance to step back and look at how far the project has come.
The project is still evolving, but today it solves real problems for real ASP.NET Core developers.
And this is only the beginning.
Top comments (0)