DEV Community: davinceleecode

Code Coverage .NET

davinceleecode — Sat, 23 May 2026 13:17:45 +0000

Code Coverage .NET

For .NET projects, the most common manual way is using:

coverlet
or built-in dotnet test --collect:"XPlat Code Coverage"

Simplest first:

dotnet test --collect:"XPlat Code Coverage"

After running, you’ll see something like:

Attachments:
.../coverage.cobertura.xml

That XML file contains the coverage result.

Then install the report generator globally:

dotnet tool install -g dotnet-reportgenerator-globaltool

Generate an HTML report:

If this is not working target directly the result file

reportgenerator -reports:**/coverage.cobertura.xml -targetdir:coveragereport

target result file

reportgenerator -reports:TestResults/{ID}/coverage.cobertura.xml -targetdir:coveragereport

Then open:

coveragereport/index.html

You’ll see:

Line coverage
Branch coverage
Covered/not covered lines
Per class/service/controller coverage

Typical enterprise flow:

dotnet test
-> code coverage
-> stryker mutation test
-> CI/CD quality gate

Question

What is the official steps after setting-up above?

dotnet test --collect:"XPlat Code Coverage"

and

If this is not working target directly the result file

reportgenerator -reports:**/coverage.cobertura.xml -targetdir:coveragereport

target result file

reportgenerator -reports:TestResults/{ID}/coverage.cobertura.xml -targetdir:coveragereport

Then open:

coveragereport/index.html

COVERLET

Coverlet is the more common approach in real .NET projects now because it integrates nicely with CI/CD and gives flexible reporting.

Here’s the normal flow.

1. Install Coverlet in your TEST project

Inside your test project folder:

dotnet add package coverlet.msbuild

This adds the MSBuild integration of Coverlet.

2. Run coverage manually

dotnet test /p:CollectCoverage=true

After running, you’ll see something like:

+--------+------+--------+--------+
| Module | Line | Branch | Method |
+--------+------+--------+--------+

and a generated file:

coverage.json

3. Generate HTML report (better UI)

Usually we use Cobertura format:

dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura

Then generate HTML:

reportgenerator -reports:coverage.cobertura.xml -targetdir:coveragereport

Open:

coveragereport/index.html

Future workflow now

Whenever code changes:

dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura

then:

reportgenerator -reports:coverage.cobertura.xml -targetdir:coveragereport

Difference from built-in collector

Built-in collector:

dotnet test --collect:"XPlat Code Coverage"

Coverlet MSBuild:

dotnet test /p:CollectCoverage=true

Both are valid.

But Coverlet gives:

easier CI/CD integration
thresholds
filtering
merging reports
multiple formats
more enterprise flexibility

Example threshold:

dotnet test /p:CollectCoverage=true /p:Threshold=80

This FAILS the build if coverage goes below 80%.

Fastest Way to Understand Stryker

davinceleecode — Fri, 22 May 2026 14:57:01 +0000

FASTEST WAY TO UNDERSTAND STRYKER

We'll create:

Console App
   ↓
Class Library
   ↓
Unit Test Project
   ↓
Run Stryker

You’ll understand:

solution structure
testing flow
mutation testing
enterprise-level quality tooling

STEP 1 - Create Solution

Open terminal:

mkdir StrykerDemo
cd StrykerDemo

dotnet new sln

STEP 2 - Create Class Library

This contains business logic.

dotnet new classlib -n StrykerDemo.Core

Add to solution:

dotnet sln add StrykerDemo.Core

STEP 3 - Create Test Project

Use xUnit.

dotnet new xunit -n StrykerDemo.Tests

Add to solution:

dotnet sln add StrykerDemo.Tests

Reference Core project:

dotnet add StrykerDemo.Tests reference StrykerDemo.Core

STEP 4 - Create Actual Logic

Inside:

StrykerDemo.Core

Create:

namespace StrykerDemo.Core;

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

STEP 5 - Create Unit Test

Inside test project:

using StrykerDemo.Core;

namespace StrykerDemo.Tests;

public class CalculatorTests
{
    [Fact]
    public void Add_Should_Return_Correct_Value()
    {
        var calculator = new Calculator();

        var result = calculator.Add(2, 3);

        Assert.Equal(5, result);
    }
}

STEP 6 - Verify Tests

Run:

dotnet test

You should see:

Passed!

STEP 7 - Install Stryker

Install globally:

dotnet tool install -g dotnet-stryker

Verify:

dotnet stryker --version

STEP 8 — RUN STRYKER

Go to test project:

cd StrykerDemo.Tests

Run:

dotnet stryker

WHAT HAPPENS NOW

Stryker will:

Find your code
Mutate it
Run tests repeatedly

Example mutation:

Original:

a + b

Mutated:

a - b

Your test expects:

Mutated result:

-1

Test fails.

Mutation killed ✅

NOW LET’S SEE A SURVIVING MUTATION

Change test to weak test:

Assert.True(result > 0);

instead of:

Assert.Equal(5, result);

Now rerun Stryker.

Some mutations may survive because:

subtraction may still return positive
your assertion is too generic

THIS is where mutation testing becomes powerful.

Viewing the Stryker HTML Report

After running:

dotnet stryker

Stryker automatically generates an HTML report inside:

StrykerOutput/<timestamp>/reports/mutation-report.html

Example:

StrykerOutput/2026-05-23.14-56-48/reports/mutation-report.html

You can also automatically open the report in your browser:

dotnet stryker --open-report

dotnet stryker -o

THE BIG ENTERPRISE INSIGHT

In real enterprise systems:

code coverage can say 90%
but mutation score may say 40%

Meaning:

tests execute code but don’t truly verify behavior.

That’s why mature engineering teams use:

unit tests
integration tests
mutation testing
quality gates in CI/CD

HOW THIS LOOKS IN GITHUB

Usually:

GitHub Actions
    ↓
dotnet test
    ↓
dotnet stryker
    ↓
Fail pipeline if mutation score low

This is where you begin seeing:

real engineering ownership
architecture visibility
DevOps quality flow
not just user story implementation

WHAT YOU SHOULD DO NEXT

After this basic example:

Add more methods
Add edge cases
Purposely create weak tests
Watch mutations survive
Improve tests
Re-run Stryker That loop teaches more than tutorials.

Azure Integration Services – Complete Guide

davinceleecode — Thu, 12 Feb 2026 15:23:40 +0000

Modern applications rarely run in isolation. They need to communicate with other apps, services, databases, and external systems — both in the cloud and on-premises.

Azure Integration Services help you connect, automate, and orchestrate these systems reliably and at scale.

In this post, we’ll explore the key Azure Integration Services like:

Azure Service Bus
Azure Storage Queue
Azure Event Grid
Azure Event Hubs
Azure Logic Apps
Azure API Management
And more

✅ Messaging Services

1️⃣ Azure Service Bus

Enterprise-grade messaging service

🔧 Features:

Queues and Topics (Pub/Sub)
FIFO support
Transactions
Dead-letter queues
Duplicate detection
Scheduled messages

🎯 Best For:

Reliable communication between microservices
Financial systems
Order processing
Complex enterprise messaging

2️⃣ Azure Storage Queues

Simple, scalable message queue

🔧 Features:

Massive scalability
Cost-effective
Basic queue functionality
At-least-once delivery

🎯 Best For:

Background jobs
Lightweight async processing
Simple decoupling between services

3️⃣ Azure Event Grid

Event-based Pub/Sub (Push Model)

🔧 Features:

Push-based delivery
Built-in Azure event sources
Custom events support
Low latency

🎯 Best For:

Event-driven architectures
Reacting to Blob uploads
Resource lifecycle events
Serverless automation

4️⃣ Azure Event Hubs

Big Data Streaming Platform

🔧 Features:

Millions of events per second
Partitioning
Capture to Blob/Data Lake
Integration with Stream Analytics

🎯 Best For:

Telemetry ingestion
IoT data streams
Log streaming
Real-time analytics

✅ Workflow & Orchestration

5️⃣ Azure Logic Apps

Low-code workflow automation

🔧 Features:

1000+ connectors (SAP, Salesforce, Outlook, etc.)
Visual designer
Built-in retry policies
Hybrid connectivity

🎯 Best For:

Business process automation
System integration without heavy coding
Enterprise workflows

6️⃣ Azure Functions

Event-driven serverless compute

🔧 Features:

Auto-scaling
Pay-per-execution
Triggers (Service Bus, Event Grid, HTTP, etc.)

🎯 Best For:

Event handlers
Lightweight APIs
Background processing

7️⃣ Azure Durable Functions

Stateful serverless workflows

🔧 Features:

Long-running workflows
Fan-out/Fan-in patterns
Human interaction workflows
Orchestration patterns

🎯 Best For:

Complex multi-step processes
Stateful orchestration
Approval workflows

✅ API & Connectivity Services

8️⃣ Azure API Management (APIM)

Full API Gateway Solution

🔧 Features:

Authentication & authorization
Rate limiting
Caching
API transformation
Developer portal

🎯 Best For:

Securing APIs
Monitoring API usage
Monetizing APIs

9️⃣ Azure Relay

Secure Hybrid Connectivity

🔧 Features:

No inbound firewall ports needed
Hybrid connection support

🎯 Best For:

Exposing on-prem services securely
Hybrid cloud solutions

🔟 Azure Web PubSub

Real-time messaging via WebSockets

🎯 Best For:

Chat applications
Live dashboards
Real-time notifications

✅ Data Integration

1️⃣1️⃣ Azure Data Factory

Cloud ETL/ELT Service

🔧 Features:

Data pipelines
90+ connectors
Data transformation
Scheduled workflows

🎯 Best For:

Moving data between systems
Data warehousing
Large-scale data integration

🔥 Quick Comparison Table

Service	Primary Use Case
Service Bus	Enterprise messaging
Storage Queue	Simple async processing
Event Grid	Event-driven automation
Event Hubs	High-volume streaming
Logic Apps	Low-code workflows
Functions	Serverless compute
API Management	API governance
Data Factory	Data pipelines

🏗 When to Use What?

Need reliable enterprise messaging? → Service Bus
Need simple background processing? → Storage Queue
Need event-based automation? → Event Grid
Need massive streaming ingestion? → Event Hubs
Need business workflow automation? → Logic Apps
Need API gateway? → API Management

🚀 Final Thoughts

Azure Integration Services provide powerful building blocks for modern cloud architectures.

Whether you're building microservices, event-driven systems, hybrid integrations, or enterprise workflows — Azure has a service designed for it.

If you're preparing for Azure certifications (AZ-204, AZ-305) or designing enterprise systems, mastering these services is essential.

💬 What Azure Integration Service do you use most in your architecture?

SQL Normalization vs Denormalization Explained with 1NF, 2NF, and 3NF

davinceleecode — Tue, 10 Feb 2026 04:05:32 +0000

SQL Normalization vs Denormalization: A Beginner-Friendly Guide

When designing a database, one of the most common questions is:

Should I normalize my tables, or denormalize for performance?

Let’s break it down in simple terms and see how 1NF, 2NF, and 3NF fit into the picture.

What is Normalization?

Normalization is the process of organizing your database tables to:

Reduce redundancy (duplicate data)
Avoid update anomalies
Maintain data integrity

The goal is to split data into multiple related tables, linked via primary and foreign keys.

Example: Normalized Database

Customers Table

customer_id	name	email
1	Alice	alice@mail.com
2	Bob	bob@mail.com

Orders Table

order_id	customer_id	order_date
101	1	2026-02-01
102	2	2026-02-03

✅ No customer info is repeated in orders.

✅ Updates to a customer's email happen in one place only.

What is Denormalization?

Denormalization is the opposite: we intentionally add redundancy to make queries faster or simpler.

Example: Denormalized Database

Orders Table (Denormalized)

order_id	customer_id	customer_name	customer_email	order_date
101	1	Alice	alice@mail.com	2026-02-01
102	2	Bob	bob@mail.com	2026-02-03

✅ Faster reads (no JOIN needed)

❌ Risk of inconsistent data if a customer's info changes

When to Normalize vs Denormalize

Scenario	Recommendation
Core transactional system (OLTP)	Normalize
Read-heavy reports/dashboard	Denormalize
Frequent updates	Normalize
Mostly read-only data	Denormalize

Most systems start normalized and denormalize selectively for performance.

The 1NF, 2NF, and 3NF Rules

Normalization is applied in stages, called normal forms. Here’s the beginner-friendly breakdown:

1NF (First Normal Form)

Rule: Each column must contain atomic values (no lists or arrays).

❌ Bad:

id | name | phones
1 | Sam | 111, 222, 333

✅ Good:

Students Table

id	name
1	Sam

Phones Table

student_id	phone_number
1	111
1	222
1	333

2NF (Second Normal Form)

Rule: No partial dependency; all non-key columns must depend on the whole primary key.

❌ Bad:

Enrollments Table

student_id	course_id	student_name
1	101	Sam

Primary key: (student_id, course_id)
student_name depends only on student_id ❌

✅ Good:

Students Table

student_id	student_name
1	Sam

Enrollments Table

student_id	course_id
1	101

3NF (Third Normal Form)

Rule: No transitive dependency; non-key columns should depend only on the primary key.

❌ Bad:

Employees Table

emp_id	dept_id	dept_name
1	10	HR

dept_name depends on dept_id, which depends on emp_id ❌

✅ Good:

Employees Table

emp_id	dept_id
1	10

Departments Table

dept_id	dept_name
10	HR

Quick Summary

Normalize = remove duplication, enforce data integrity
Denormalize = accept duplication for faster reads
1NF = atomic values
2NF = no partial dependencies
3NF = no transitive dependencies

Most systems aim for 3NF, then denormalize only where performance demands it.

Conclusion

Normalization ensures your database is clean, consistent, and easy to maintain.

Denormalization sacrifices some cleanliness to improve performance.

Understanding 1NF–3NF gives you the tools to design better databases, and knowing when to denormalize keeps your apps fast.

Tip: Start normalized. Optimize with denormalization only when necessary.

AI Genie: A Multimodal Q&A Assistant with Google Gemini

davinceleecode — Sun, 07 Sep 2025 07:33:37 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

I built AI Genie, a simple web app that lets users ask any question and get AI-generated answers in real time. Using Google Gemini via a Python Flask backend, the app sends user prompts to Gemini and returns intelligent responses instantly. This project showcases Gemini’s text understanding and generation capabilities in a general-purpose Q&A assistant.

Demo

You can try AI Genie locally or view the source code on GitHub:

Library Genie GitHub Repo

How I Used Google AI Studio

I connected my Flask web app to Google Gemini via the Generative AI API. Users type their questions, and the app sends the prompt to Gemini, which returns an answer in real time.

Multimodal Features

This project mainly demonstrates Gemini’s text generation and understanding capabilities. It can interpret user queries and generate coherent responses, showing the AI’s ability to handle general-purpose questions interactively.

[Boost]

davinceleecode — Wed, 03 Sep 2025 15:09:32 +0000

A Love Letter to Vercel!

Mahdi Jazini ・ Sep 2

#vercel #nextjs #webdev #programming

This is a submission for the [Midnight Network "Privacy First" Challenge]

davinceleecode — Fri, 29 Aug 2025 16:01:25 +0000

What I Built

I built a lightweight developer demo tool that shows how Midnight developers could prototype privacy-preserving DApps with a React + TypeScript frontend.

The tool provides a simple Anonymous Shoutbox where users can submit messages backed by a placeholder proof mechanism. It demonstrates how ZK concepts can be wired into the UI flow, making it easier for developers to experiment before integrating real Midnight Compact circuits and MidnightJS.

This solves the problem of developer onboarding, giving new builders a ready-to-use Vite + Tailwind starter project that already showcases privacy-first design patterns.

Demo

GitHub Repo: [https://github.com/davinceleecode/midnight-privacy-dapp]
Screenshot:

(Replace with actual screenshots from your app running.)

How I Used Midnight's Technology

This project is designed as a starter template for building with Midnight Compact and MidnightJS.

While the current version uses mocked proof generation, the architecture is ready to be swapped with real Midnight proof calls. This way, developers can focus on designing their UI/UX flow without needing the full ZK integration on day one.

It highlights how Midnight's privacy-preserving transaction patterns could integrate directly into the user experience.

Developer Experience Improvements

Provides a ready-to-use starter repo for privacy-first DApps.
Abstracts the boilerplate (React + Tailwind + TypeScript) so developers can jump straight into building.
Demonstrates proof lifecycle flow (input → proof → verified → message published) in a minimal, understandable way.
Open-sourced under Apache 2.0 license.

This makes it easier for developers to experiment quickly and extend the template with their own ZK circuits.

Set Up Instructions / Tutorial

Clone the repository:


bash
   git clone https://github.com/your-username/midnight-privacy-demo.git
   cd midnight-privacy-demo
<!-- Thanks for participating! -->

Major Algorithm Types Cheat Sheet

davinceleecode — Fri, 22 Aug 2025 07:19:00 +0000

1. Brute Force

Try all possibilities until you find the answer.
✅ Simple but usually slow (O(2ⁿ), O(n!)).

2. Divide and Conquer

Break problem → solve subproblems → combine results.
🔑 Examples: Merge Sort, Quick Sort, Binary Search.

3. Greedy Algorithms

Make the best local choice at each step → hope it leads to global optimum.
🔑 Examples: Dijkstra’s shortest path, Huffman coding.

4. Dynamic Programming (DP)

Break problem into overlapping subproblems.
Save (memoize) results to avoid recomputation.
🔑 Examples: Fibonacci, Knapsack, Matrix path problems.

5. Backtracking

Try a path, if it fails → go back and try another.
🔑 Examples: Sudoku solver, N-Queens, Maze solving.

6. Graph Algorithms

Work with nodes/edges (networks, maps, dependencies).
🔑 Examples: BFS, DFS, Dijkstra, Kruskal, Prim.

7. Sorting & Searching

Sorting: QuickSort, MergeSort, HeapSort, BubbleSort.
Searching: Binary Search, Linear Search.

8. Recursion

A function calls itself to solve smaller versions of a problem.
Often combined with DP, divide & conquer, backtracking.

9. Mathematical / Number Theory

🔑 Examples: GCD (Euclidean), Prime tests, Modular arithmetic.

10. String Algorithms

Work on text patterns and substrings.
🔑 Examples: KMP, Rabin-Karp, Trie-based search.

✅ TL;DR

Optimization → Greedy or DP.
Paths/Networks → Graph.
Exploring possibilities → Backtracking.
Ordering/Searching data → Sorting/Searching.
Formula-style tricks → Math/Number theory.

If you found this helpful, consider supporting my work at ☕ Buy Me a Coffee.

Time Complexity (Big-O Notation) in Algorithms

davinceleecode — Wed, 20 Aug 2025 07:09:45 +0000

1. What is Algorithm Complexity?

Algorithm = step-by-step procedure to solve a problem.
Complexity = how much time or memory it needs as input size grows.
We measure this using Big-O notation.

2. Why Big-O Notation?

It describes the growth rate, not the exact time.
Helps compare algorithms (fast vs slow) independent of hardware.
Example: One algorithm takes 1 second for 1000 inputs, another takes 10 seconds — Big-O tells us how this scales when inputs grow to 1 million.

3. Common Complexities (with examples)

🔹 O(1) → Constant time

Same time, no matter the input size.
Example: access arr[5], simple formula like n(n+1)/2.

🔹 O(log n) → Logarithmic time

Input size shrinks in half each step.
Example: Binary Search in a sorted array.

🔹 O(n) → Linear time

One loop over all n items.
Example: Find the max element in an array.

🔹 O(n log n) → Linearithmic time

Appears in efficient sorting algorithms.
Example: Merge Sort, Quick Sort.

🔹 O(n²) → Quadratic time

Double loop → compare all pairs.
Example: Bubble Sort, checking all pairs in a matrix.

🔹 O(2ⁿ) → Exponential time

Doubles work for each extra input.
Example: Recursive Fibonacci, brute force subsets.

🔹 O(n!) → Factorial time

Explodes very fast → all permutations.
Example: Traveling Salesman (brute force).

4. Formula vs Algorithm

Formula: Already solved shortcut, runs in O(1).
- Example: Sum of first n numbers = n(n+1)/2.
Algorithm: Step-by-step method to compute the answer.
- Example: Loop through numbers and add one by one = O(n).

✅ TL;DR:

Big-O tells us how fast/slow an algorithm grows with input size.
Formulas are direct (O(1)), algorithms can vary (O(n), O(n log n), etc).
Choosing the right algorithm = huge performance difference in real-world apps.

If you found this helpful, consider supporting my work at ☕ Buy Me a Coffee.

Common Challenges for developers and learners

davinceleecode — Tue, 19 Aug 2025 09:30:46 +0000

As developers, we often face challenges that aren't just technical. Today, I want to talk about three common ones that affect learning and growth: Tutorial Hell, Cognitive Load, and Imposter Syndrome.

1️⃣ Tutorial Hell

What it is:

Getting stuck in endless tutorials without building real projects. You learn a lot of tools and frameworks but never complete something meaningful.

Why it's a problem:

Knowledge is fragmented.
Confidence in applying skills is low.

Solution:

Focus on building small projects.
Finish what you start before moving to another tutorial.

2️⃣ Cognitive Load

What it is:

The mental effort required to process information. When learning multiple complex topics at once, your brain can feel overwhelmed.

Why it's a problem:

Hard to retain information.
Learning slows down, frustration increases.

Solution:

Break learning into small chunks.
Focus on one topic at a time.

3️⃣ Imposter Syndrome

What it is:

Feeling like a fraud, thinking "I'm not good enough," even when you have skills or achievements.

Why it's a problem:

Lowers confidence.
Makes you avoid challenges.

Solution:

Track your achievements.
Seek feedback from peers.
Practice and apply your skills regularly.

🔹 How They Connect

Tutorial Hell + Cognitive Load → increases the chance of Imposter Syndrome.
The key to breaking the cycle: learn by doing, chunk your learning, and celebrate small wins.

💡 Takeaway:

Stop getting stuck in tutorials. Focus, build projects, manage your cognitive load, and remember: you are learning, and you are capable.

If you found this helpful, consider supporting my work at ☕ Buy Me a Coffee.

When to Use Which Hook?

davinceleecode — Wed, 23 Jul 2025 17:15:25 +0000

React provides powerful hooks that allow you to manage state, side effects, performance optimizations, and much more — all inside functional components. Here's a concise guide on when to use each hook:

Hook	Use Case
`useState`	Manage local component state (e.g., input fields, toggles, counters)
`useEffect`	Perform side effects (e.g., data fetching, subscriptions, timers)
`useContext`	Access shared/global state without prop drilling (e.g., theme, auth)
`useRef`	Reference DOM elements or store mutable values across renders
`useReducer`	Manage complex state logic or state transitions (e.g., form wizard, cart)
`useMemo`	Optimize performance by memoizing expensive calculations
`useCallback`	Memoize functions to prevent unnecessary re-renders
`useLayoutEffect`	Execute synchronously after DOM changes but before browser paint

Example Use Cases:

Use useState for toggling modals or tracking form values.
Use useEffect to fetch data from an API when a component mounts.
Use useContext to access user authentication info across components.
Use useReducer to manage complex multi-step form data with validation.
Use useMemo to avoid recalculating filtered lists or sorting operations.
Use useCallback when passing callback props to memoized child components.
Use useLayoutEffect to measure layout before browser paint (e.g., animations or positioning).

If you found this helpful, consider supporting my work at ☕ Buy Me a Coffee.

What is Dangling DNS? (And How It Can Lead to Domain Takeovers)

davinceleecode — Wed, 09 Jul 2025 02:00:00 +0000

Ever deleted a cloud app and forgot to clean up your DNS?
You might be leaving the door open for attackers.

👀 What is a Dangling DNS?

A dangling DNS record occurs when:

A DNS record (like a CNAME or A record) still points to a cloud service (e.g. Azure App Service, AWS S3, GitHub Pages)
But the resource has already been deleted

This leaves the DNS record “dangling” — pointing to a hostname that no longer exists, but could be claimed by someone else.

🧨 Why is it Dangerous?

An attacker can:

Identify the orphaned DNS entry (e.g. blog.yoursite.com → yourapp.azurewebsites.net)
Claim the deleted resource name (e.g. create a new App Service with that exact name)
Host malicious content under your subdomain

This allows them to:

Impersonate your brand
Steal user data
Inject phishing pages
Break your site's security reputation (e.g. email domain spoofing)

🔍 Real Example

Let’s say you had:
CNAME blog.yourdomain.com → yourblog.azurewebsites.net

Then you:

Deleted the App Service yourblog on Azure
But forgot to remove the CNAME from your DNS provider

Now an attacker registers yourblog.azurewebsites.net (if available), and your blog.yourdomain.com will start pointing to them!

🛡️ How to Prevent Dangling DNS

✅ Always do these:

Clean up DNS records when deleting cloud services
Audit your DNS regularly for unused entries
Use DNS monitoring tools to detect dangling links
Enable ownership validation on platforms that support it (e.g. GitHub, Netlify)

💡 On Azure:

If you delete an App Service and used a custom domain, remove the A/CNAME/TXT records immediately

📌 TL;DR

Term	Meaning
Dangling DNS	A DNS record pointing to a deleted or unowned cloud resource
Risk	Subdomain takeover, phishing, brand impersonation
Fix	Delete unused DNS entries after decommissioning services

Have you ever found a dangling DNS record in your project? Let me know in the comments — and don’t forget to audit your DNS zones today!

If you found this helpful, consider supporting my work at ☕ Buy Me a Coffee.