Dev Tunnels with Visual Studio 2022 and Visual Studio 2026

-

 

Securely exposing your local development environment to the world — explained

Introduction

Developers building web APIs and web applications often face a familiar challenge: how to expose a localhost app to external services, collaborators, mobile devices or testing environments without deploying it to production.

Enter Dev Tunnels, a powerful feature in Visual Studio that allows you to securely share your local development server over the internet with a public or authenticated URL. It dramatically simplifies workflows involving webhooks, remote debugging, and cross-device testing. 

In this article, we’ll explore what Dev Tunnels are, how they work in Visual Studio 2022, what’s new in the context of Visual Studio 2026, and practical scenarios for using them.

What Are Dev Tunnels?

Dev tunnels let you expose a local web app running on localhost to the internet using a secure tunnel endpoint. Once created:

  • You get a remote HTTPS URL that maps to your local web server.

  • Other devices or services can access your local application without needing complex network settings.

  • The tunnel can be public or restricted with authentication. 

Think of Dev Tunnels as a developer-friendly alternative to traditional port-forwarding tools like ngrok, built directly into Visual Studio and backed by Microsoft’s secure tunneling infrastructure. tcdev.de

Dev Tunnels in Visual Studio 2022

Visual Studio 2022 (starting in version 17.6) introduced Dev Tunnels to help developers effortlessly share and test local applications.

How It Works (High-Level)

  1. Open your ASP.NET Core or web project.

  2. In the Debug dropdown, choose Dev Tunnels → Create a Tunnel.

  3. Configure the tunnel:

    • Name

    • Type: Temporary (new URL each run) or Persistent (same URL across restarts)

    • Authentication: Public, Private, or Organizational.

  4. Run your project, Visual Studio gives you a live HTTPS tunnel URL that proxies to your local app. 

Once active, your application’s browser launches with the tunnel URL instead of localhost. Requests hitting that URL are routed back to your running development server. 

Use Cases

Dev Tunnels shine in scenarios such as:

  • Testing APIs from different devices (phones, tablets, remote workstations) without deploying.

  • Receiving webhooks from external services directly into localhost.

  • Collaborating or demoing work in progress with teammates or clients.

  • Debugging across environments — including integrations with Power Platform, mobile apps, or cloud workflows. 

Benefits

  • No need for external tools, it’s built into Visual Studio.

  • Supports authenticated access for secure sharing.

  • Persistent tunnels aren’t ephemeral, great for long-lived tests.

  • Useful in both API and full web app development. 

Visual Studio 2026 and Dev Tunnels

Visual Studio 2026 continues to support and enhance the Dev Tunnels experience as part of its growing toolkit for cloud-native and AI-assisted development. While the focus in VS 2026 release notes is on AI innovations and toolchain improvements, Dev Tunnels remain relevant as part of the modern developer workflow — particularly in contexts where remote URLs simplify testing and collaboration. 

What’s New in VS 2026 (General)

Visual Studio 2026 introduces features like:

  • Copilot Cloud Agent integration

  • AI-assisted developer workflows (context menus, smarter search)

  • Improved performance and tooling

Although Microsoft’s 2026 documentation doesn’t yet announce specific Dev Tunnels upgrades, the ongoing evolution of Visual Studio suggests:

  • Even smoother tunnel creation and management.

  • Better IDE integration with AI tools.

  • Expanded cloud and remote capabilities baked into the development experience.

Your existing Dev Tunnels workflows from VS 2022 should continue to work and integrate naturally with these broader enhancements. 

Best Practices and Tips

Private vs Public Tunnels

  • Private tunnels restrict access to authenticated users.

  • Public tunnels are open to anyone who has the URL, useful for demos but should be used cautiously. 

When to Use Persistent Tunnels

If your API needs to be registered with an external service (for example, a webhook callback URL), a persistent tunnel ensures that your URL stays consistent across debugging sessions. 

Security Considerations

Dev Tunnels expose your development environment, always consider:

  • Using private or organization scopes for sensitive work.

  • Restricting what your local server exposes.

  • Avoiding use in public production contexts.

Real-World Example

Imagine you’re building a payment webhook handler for Stripe or PayPal. These services need a publicly accessible URL to send webhook events, yet deploying every change to a cloud environment just to test is slow and costly.

With Dev Tunnels:

  • You get a live public HTTPS URL to your local webhook handler.

  • Configure the webhook provider with this URL.

  • Hit breakpoints locally when events are received.

This dramatically shortens the feedback loop, and makes local testing feel like production testing.

Dev Tunnels Beyond ASP.NET

Dev Tunnels also support other integrations:

  • Power Platform custom connectors

  • Power Apps / Power Automate testing

  • Mobile apps connecting to local backends

  • Tools that require callback URLs or remote endpoints.

Conclusion

Dev Tunnels represent one of the most practical developer productivity features in modern Visual Studio:

✅ Share local APIs securely
✅ Debug remote requests locally
✅ Test integrations without deployment
✅ Expand collaboration across devices and teams

Whether you’re using Visual Studio 2022 or stepping into Visual Studio 2026, Dev Tunnels fit squarely into a modern development cycle,  empowering you to move fast without friction.

Comments

Post a Comment

Popular posts from this blog

Using a Semantic Model as a Reasoning Layer (Not Just Metadata)

-
Image
  Part 1: Using a Semantic Model as a Reasoning Layer (Not Just Metadata) Most systems treat semantic models as documentation. But what if they were active participants in query execution? This question came up while thinking about natural language analytics. Natural Language Is Ambiguous by Default If someone asks: “Show me sales by product this year” There are immediate ambiguities: Which sales measure? At what product level? Calendar or fiscal year? Gross or net? Most tools resolve this by: Picking defaults Or asking the user to clarify But what if the system could reason about the question? The Semantic Model as Context Imagine a model that explicitly defines: Valid measures Valid rollups Default aggregation logic Synonyms and aliases Before executing anything, the system can ask: Is this aggregation valid? Are these measures comparable? Does this level change meaning? This shifts failure from: “The numbers look...
Read more

A Thought Experiment: What If Analytics Models Were Semantic, Not Structural?

-
Image
I’ve been thinking a lot about why analytics and forecasting platforms feel harder to use than they should. Not harder to build,  harder to think with . Most modern data stacks are incredibly capable: Fast databases Columnar storage In-memory caches ML forecasting libraries Yet the questions users struggle to answer haven’t changed much: “Compared to what?” “At what level?” “Is this rolled up correctly?” “Why does this number look wrong?” This feels less like a compute problem and more like a meaning problem . Where Meaning Lives Today In most systems I’ve worked on, meaning is scattered across: Database schemas ETL logic Cube definitions BI metadata Tribal knowledge None of this is explicit. If someone asks: “Can we compare forecast vs actual by category this year?” The system doesn’t reason about that question. It executes SQL and hopes the result makes sense. A Different Framing What if we treated analytics as a sem...
Read more