Forem: Daniel Schroeder

Host website PR previews on GitHub Pages for free

Daniel Schroeder — Tue, 07 Apr 2026 00:00:00 +0000

GitHub Pages allows you to host one static website per repository for free. The URL is typically in the format https://<username>.github.io/<repository>/, and you can use it to host your project’s documentation, portfolio, or any static content. I use it to host this blog for free, along with a custom domain name.

The problem; hosting PR previews

Recently, I wanted to preview some changes I was making to my blog before merging them into the main branch. I can run the site locally on my PC, but wanted to preview it from my phone, and share the link with my wife to get her feedback.

Since GitHub Pages only gives you one URL per repo, the typical advice is to use a 3rd party hosting service like Netlify, Vercel, AWS, or Azure to host PR preview sites. You can use a GitHub Actions workflow to deploy the preview version of your site to the external service when a PR is opened, and it will get a unique URL that you can share with others. GitHub even has official documentation on how to deploy PRs to services like Azure Static Web Apps.

Even though some of these services have free tiers, I didn’t want to sign up for another hosting platform, deal with API keys, or depend on a 3rd party service just for PR previews. I wanted everything to remain in GitHub.

There are long-standing issues asking GitHub to allow hosting PR previews directly on GitHub Pages, such as this one. Unfortunately, it doesn’t look like it will be implemented anytime soon. Luckily, I found a workaround.

A simple solution

Rather than hosting multiple static websites on different subdomains, simply host them all on the same domain, but in different subdirectories. Essentially, your PR previews can be hosted inside your production website, just in a deeper path.

So to visit your production site you would go to https://<username>.github.io/<repository>/, and to visit your PR preview site you might go to https://<username>.github.io/<repository>/previews/pr-123/, where 123 is the PR number.

Caveats

There are some caveats with this approach:

For non-generated sites, assets must be referenced with relative paths so they work in both the production and preview sites.
- I use Jekyll as my static site generator and simply set the baseurl in the config when building the site. All asset references are relative to the base URL.
The PR preview site is publicly accessible by default, which may not be desirable, especially for closed-source projects where you don’t want to expose unfinished work.
To prevent web crawlers from indexing the PR previews, you should update your robots.txt file to disallow crawling of the previews subdirectory.
Your production site analytics may be skewed by traffic to the PR previews.

Since my use case is simply my public open-source blog, these caveats are not a concern for me.

An example workflow

The basic workflow is as follows:

When a PR is opened, deploy the preview version of the site to a subdirectory named after the PR number, and post a comment in the PR with the URL to the preview site.
If the PR is updated, redeploy the preview site with the latest changes.
When the PR is closed, delete the preview site.

Here’s an example PR comment with the preview URL that can get posted by the workflow:

Let’s see how to configure the GitHub repo and set up GitHub Actions workflows to take care of this for us. The examples shown are from my blog GitHub repo, for reference: https://github.com/deadlydog/Blog

Configuring the GitHub repo

You will need to configure your GitHub repo settings to enable GitHub Pages and to deploy from a branch, typically the gh-pages branch.

In your GitHub repo settings:

Go to the Pages section.
Ensure the build and deployment Source is set to Deploy from a branch.
For the Branch, select gh-pages and the root folder.
Optionally, if you have a custom domain name, you can set it up here as well.
- This will require some DNS configuration to point your custom domain to GitHub Pages. I will not cover it here, as you can read the GitHub documentation on how to set that up.

Now whenever changes are pushed to the gh-pages branch, GitHub Pages will automatically build and deploy the site, and it will be available at the URL specified in the settings.

This is how you host your production site. The next step is to have PR previews automatically deployed to subdirectories within it.

Setting up GitHub Actions workflows

You will need to set up 2 GitHub Actions workflows:

One to deploy the PR preview site when a PR is opened or updated, and to delete it when the PR is closed.
Another to deploy the production site to the gh-pages branch when changes are merged into the main branch.

PR preview to gh-pages workflow

Below is an example workflow for deploying PR previews to a previews subdirectory within the gh-pages branch. It also updates the PR with a comment containing the URL to the preview site. When the PR is closed, the workflow deletes the preview site from the gh-pages branch.

You can view the latest version of this pr-preview.yml workflow here.

This workflow has some Jekyll-specific steps, but the general idea can be adapted to your needs.

# Builds and deploys the Jekyll site for PRs to the "previews" directory on the
# gh-pages branch, and posts a comment with the preview URL to the PR.
# Also removes the preview from gh-pages when the PR is closed (merged or abandoned).

name: Deploy PR preview to gh-pages

on:
  pull_request:
    types: [opened, synchronize, reopened, closed]

permissions:
  contents: write
  pull-requests: write

jobs:
  # ─── Deploy preview on PR open / update ──────────────────────────────────
  deploy-preview:
    if: github.event.action != 'closed'
    runs-on: ubuntu-latest
    concurrency:
      group: pr-preview-deploy-${{ github.event.pull_request.number }}
      cancel-in-progress: true
    steps:
      - uses: actions/checkout@v4

      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.3'
          bundler-cache: true

      - name: Build Jekyll preview site
        shell: pwsh
        env:
          JEKYLL_ENV: production
          JEKYLL_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          # Write a temporary config that overrides baseurl for the preview path.
          @"
          url: "https://blog.danskingdom.com"
          baseurl: "/previews/pr-${{ github.event.pull_request.number }}"
          "@ | Set-Content -Path /tmp/_config_preview.yml

          bundle exec jekyll build --config _config.yml,/tmp/_config_preview.yml --destination ./_site_preview

      - name: Deploy preview to gh-pages branch previews subdirectory
        uses: peaceiris/actions-gh-pages@v4
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./_site_preview
          destination_dir: previews/pr-${{ github.event.pull_request.number }}
          keep_files: true
          commit_message: "Deploy preview for PR #${{ github.event.pull_request.number }} (${{ github.sha }})"

      - name: Post / Update preview URL comment on PR
        uses: actions/github-script@v7
        with:
          script: |
            const prNumber = context.payload.pull_request.number;
            const previewUrl = `https://${context.repo.owner}.github.io/${context.repo.repo}/previews/pr-${prNumber}/`;
            const marker = '<!-- pr-preview-bot -->';
            const body =
              `${marker}\n` +
              `🔍 **PR Preview deployed:** ${previewUrl}\n\n` +
              `_This preview is updated on every commit and will be removed when the PR is closed._`;

            const { data: comments } = await github.rest.issues.listComments({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: prNumber,
            });

            const existing = comments.find(c => c.body.includes(marker));
            if (existing) {
              await github.rest.issues.updateComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                comment_id: existing.id,
                body,
              });
            } else {
              await github.rest.issues.createComment({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: prNumber,
                body,
              });
            }

  # ─── Clean up preview when PR is closed (merged or abandoned) ────────────
  cleanup-preview:
    if: github.event.action == 'closed'
    runs-on: ubuntu-latest
    concurrency:
      group: pr-preview-cleanup-${{ github.event.pull_request.number }}
      cancel-in-progress: false
    steps:
      - uses: actions/checkout@v4

      - name: Remove preview directory from gh-pages branch
        shell: pwsh
        run: |
          # Guard: if gh-pages doesn't exist yet there is nothing to clean up.
          git ls-remote --exit-code --heads origin gh-pages *> $null
          if ($LASTEXITCODE -ne 0) {
            Write-Host "gh-pages branch does not exist - nothing to clean up."
            exit 0
          }

          # Fetch and create a local tracking branch so 'git checkout' works.
          git fetch origin gh-pages:gh-pages --depth=1
          git checkout gh-pages

          $prDir = "previews/pr-${{ github.event.pull_request.number }}"
          if (Test-Path $prDir) {
            git config user.name "github-actions[bot]"
            git config user.email "github-actions[bot]@users.noreply.github.com"
            git rm -r -f $prDir
            git commit -m "Remove preview for PR #${{ github.event.pull_request.number }}"
            git push --set-upstream origin gh-pages
          }
          else {
            Write-Host "Preview directory '$prDir' not found - nothing to clean up."
            exit 0
          }

Main branch to gh-pages workflow

Below is an example workflow for deploying the production site to the gh-pages branch when changes are merged into the main branch. A key part of the workflow is preserving the previews subdirectory on the gh-pages branch, which contains the PR previews, so that they are not wiped out when the main production site is redeployed.

You can view the latest version of this deploy-site.yml workflow here.

# Builds the Jekyll site from main and pushes it to the gh-pages branch,
# while preserving any PR preview directories that already exist there.

name: Deploy main to gh-pages

on:
  push:
    branches: [main]
  workflow_dispatch:

permissions:
  contents: write

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.3'
          bundler-cache: true

      - name: Build Jekyll site
        shell: pwsh
        env:
          JEKYLL_ENV: production
          JEKYLL_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          # Override baseurl so the github-pages gem does not inject the
          # repository name (/Blog) as the baseurl, which would break asset paths.
          @"
          url: "https://blog.danskingdom.com"
          baseurl: ""
          "@ | Set-Content -Path /tmp/_config_deploy.yml

          bundle exec jekyll build --config _config.yml,/tmp/_config_deploy.yml

      # Preserve any PR preview directories that already live on gh-pages so
      # that a main-site redeploy does not wipe them out.
      - name: Restore previews directories from gh-pages branch (if present)
        shell: pwsh
        run: |
          git ls-remote --exit-code --heads origin gh-pages *> $null
          if ($LASTEXITCODE -ne 0) {
            Write-Host "gh-pages branch does not exist yet - skipping restore."
            exit 0
          }

          git fetch origin gh-pages --depth=1

          # Copy the previews tree into the freshly built _site so the
          # subsequent deploy action includes it in the push.
          git checkout origin/gh-pages -- previews/ 2>$null
          if ($LASTEXITCODE -eq 0) {
            Copy-Item -Recurse -Force previews _site/previews
            Remove-Item -Recurse -Force previews
          }
          else {
            Write-Host "No previews directory on gh-pages yet - skipping restore."
            exit 0
          }

      - name: Deploy to gh-pages branch
        uses: peaceiris/actions-gh-pages@v4
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./_site
          cname: blog.danskingdom.com
          commit_message: "Deploy main site from ${{ github.sha }}"

Update robots.txt to ignore preview sites

One optional, but recommended step, is to update your robots.txt file to disallow web crawlers from indexing the PR preview sites. This will prevent the previews from showing up in search engine results, and users getting 404 errors when the previews are eventually removed after the PR is closed.

In your site’s robots.txt file, add:

# Prevent all web crawlers from indexing PR previews.
User-agent: *
Disallow: /previews/

If the file is typically generated by your static site generator, you may need to include the lines that it would typically generate, such as the link to your sitemap file. You can view my site’s robots.txt file here as an example.

Conclusion

By hosting PR previews in subdirectories on the same GitHub Pages site, you can have free and easy PR previews without needing to set up an external hosting service.

I’ve shown how to configure your GitHub repo, and provided example GitHub Actions workflows to automate the deployment of PR previews and the main site.

I hope you found this helpful, and that it inspires you to set up PR previews for your own GitHub Pages sites!

Happy coding!

The part of the SDLC nobody talks about, and many companies don’t do properly

Daniel Schroeder — Mon, 30 Mar 2026 00:00:00 +0000

The most neglected phase of the software development lifecycle (SDLC) is often the decommissioning phase. An app has reached end-of-life, users are no longer using it, and everything should be shut down and deleted. It seems straightforward enough, but many companies overlook this phase, or do it poorly.

Failing to properly decommission services can lead to significant costs, both obvious and hidden.

TL;DR

Unused services and resources are costly in many ways, including money, creating noise in monitoring and alerting systems, adding mental overhead for teams, and potentially creating security vulnerabilities.
It’s best to decommission services as soon as you know they are no longer needed.
It’s important to have a clear process and checklist for decommissioning services, to ensure all of the resources get cleaned up properly and nothing gets missed.
- This article provides a starting process and checklist that you can build off of.
Decommissioning a service is not free, but the costs of not doing it properly are much higher in the long run.

Zombie resources

If teams are diligent, they’ll remember to remove all of the resources their application used. However, it’s common for teams to clean up some resources, but forget others. The resources left behind and not doing anything are referred to as “zombie resources”.

For example, teams may delete the app service, but forget to delete the database, or the backups. They might remove their application from a Virtual Machine (VM), but leave the VM running. They might delete the app, but forget to remove the DNS records, load balancer rules, or monitoring alerts.

Recent statistics show that roughly 30% of cloud spend is wasted on unused or underutilized resources. The cost of these zombie resources can really add up over time, especially if teams just keep adding more of them.

Why services remain running after they are no longer needed

It’s easy to understand why people rush through the decommissioning phase and do not do it properly, or why sometimes it gets skipped altogether:

Product and development teams want to focus on creating new features and fixing bugs; things that add value and bring in more revenue. Deleting things may not feel feel like it adds value, so it may get deprioritized.
Org restructures may result in services being handed off to different teams, and the new team may not even realize the service exists.
Sometimes a solo developer is responsible for a service, and when they leave the company, the service gets forgotten about.
Developers will often spin up sandbox environments for testing and experimentation, and then forget to clean them up when they are done.

There are many other reasons, but these are the common ones I’ve seen.

Obvious costs of not decommissioning properly

If you have a cloud service that is no longer in use, but still running, you are likely paying monthly for:

The compute resources (VMs, containers, app services, functions/lambdas, etc.)
Storage costs (databases, file storage, backups, etc.)
Networking costs (data transfer, load balancers, etc.)
Software licensing costs (per user or per instance licenses)
Monitoring and alerting costs (pay per node, or ingestion rates for logs and metrics)

These monetary costs can be easy to identify, but only if you think to go looking for them. Some companies have a dedicated FinOps team whose job is to identify and eliminate these kinds of wasteful expenses. Many companies don’t though.

Often times cloud costs are lumped together into one single number, rather than broken down by department, project, or team. It’s not always easy for a dev team to identify which costs are theirs and know how much they are spending, especially if they are not organizing their resources properly or using tags/labels.

Sometimes the only people who even see the costs are the finance team when paying the bill. They won’t have the context to know if the amount is reasonable or not; they’ll just pay it.

Even if the workloads are all on-premises, there are still potential monetary costs associated with keeping unused services around. They take up compute and storage resources that could be used for other things. Infrastructure teams may think they need to purchase additional hardware sooner than they actually do.

Hidden costs of not decommissioning properly

Aside from the monetary hosting costs, there are hidden costs of not decommissioning apps, or only partially decommissioning them, that can be just as expensive.

System load and performance costs

You might have a cron job or processor service running that’s no longer necessary, making unnecessary requests, generating logs, and putting additional load on the system.
The service might be a noisy neighbour that causes performance issues for other services still in use on the same infrastructure.
It can create noise in monitoring and alerting systems, making it harder to identify real issues and lead to alert fatigue.

Mental costs of keeping old services around

It creates a larger inventory of things to keep track of, creating additional mental overhead and cognitive load for teams.
It can be worrying to have a bunch of unknown services running in your environment, especially if you don’t know what they are for or who is responsible for them.
- If they do eventually get assigned to a team, the team may feel stressed about having to be responsible for something they don’t understand or have any knowledge around.
It can lead to a hesitancy of making changes for fear of breaking something, slowing progress.

People time costs

You may need to have several meetings with different teams to figure out what a service is for, who is using it, and whether it can be safely decommissioned. Taking time out of people’s days is costly in terms of their hourly wages, but more importantly, it introduces context switching and lost productivity where they could have been working on something else.
Updating dependencies (e.g. the .NET version or 3rd party libraries) can take a lot of time, especially if the service requires manual testing and deployment.
Unnecessary components may be needlessly migrated during platform migrations. If you have a service that is no longer needed, but you don’t know it, time and effort will likely be spent migrating it to the new platform. This could be migrating it to a new hosting environment (e.g. Azure App Service to Kubernetes), or updating the app to send logs and metrics to a new monitoring platform (e.g. New Relic to Azure Monitor).
Leads to inaccurate reports about what is in their current infrastructure, which may impact planning and decision making for things like capacity planning, budgeting, migrations, etc.
Automated jobs take longer to run (e.g. managing resources with scripts, IaC deployments, etc), so people wait longer for them to complete.

Security costs

Dangling DNS vulnerabilities when DNS is not decommissioned properly.
Paying for security scanning and monitoring of unused services.
More services that need to be patched to avoid vulnerabilities and attacks.
It can create noise in security monitoring and vulnerability scanning, making it harder to identify real threats and leading to security fatigue.

Decommissioning safely

If you’re able to decommission a service that you know is no longer used, you can often move straight to deleting the resources.

If you’re not certain whether anything still relies on a service or component though, you likely want to take a few precautions before deleting it.

A typical decommission flow might look something like this:

Review logging and monitoring data to ensure the service is no longer being used.
- If things are still calling the service, you should get those updated first to stop calling it.
Notify the relevant teams and stakeholders of the decommission plans, including when it will be disabled.
Disable any alerts associated with the service to avoid false paging or notifications.
Disable the service in a way that is quick and easy to revert to perform a scream test (i.e. turn it off any see if anybody screams).
- e.g. Stop the Azure Web App, disable the cron job, update the k8s manifest, turn the Virtual Machine off, remove the DNS hostname, etc.
Wait a period of time to ensure nothing blows up (e.g. a week), or perform a brownout schedule.
- Depending on the service, consider waiting longer if needed. e.g. Do month-end reports call the service? If so, leave it disabled over the month-end period before deleting it.
Delete the service and all of the infrastructure supporting it.
Delete any monitoring and alerting associated with the service.
Backup and delete any data stores associated with the service.
Delete or archive the code and any metadata associated with the service.

You would want to perform the above steps in your non-production environments first, to minimize the risk of unexpected consequences when doing it in production.

Decommission checklist

Ideally you have everything defined in a central place as infrastructure as code; this makes finding and deleting everything easy.

That’s often not a reality for many teams though. The next best thing is to have all of the infrastructure components documented somewhere, such as docs in the app’s git repo.

Below is a non-exhaustive list of things to consider deleting when decommissioning a service, to hopefully ensure nothing is missed.

Monitoring and observability

Remove endpoints/nodes from availability checks (e.g. New Relic Synthetics, SolarWinds Orion, Azure Application Insights, etc.).
- Do this first so on-call personnel don’t get paged unnecessarily.
Delete related dashboards, alerts, SLIs, and SLOs (e.g. Application Insights, Hosted Graphite, SolarWinds, Honeycomb, Datadog, etc.).

Infrastructure

Delete compute resources, such as Web Apps, Cloud Services, Functions/Lambas, Virtual Machines, etc.
Delete empty App Service Plans and/or shuffle them if they are unbalanced after deleting a Web App.
Delete empty resource groups and subscriptions.
Delete Kubernetes resources and namespace (if applicable).
Delete secret stores (e.g. Azure Key Vault).
Delete service principals (e.g. Enterprise Application and Application Registrations from Azure Entra ID).
Delete traffic manager profiles, load balancer rules, and DNS records.
Delete any related API Management resources (e.g. Azure API Management).
Remove integrations with any other 3rd party services.

Data

Backup (if necessary) and delete databases and data stores (e.g. Azure storage accounts, SQL databases, Redis caches, Elasticsearch, etc.).
Delete service bus queues, topics, and subscribers.
Delete CDN endpoints (e.g. Azure CDN, Azure Front Door)
Delete API keys from 3rd party services (e.g. SendGrid, Honeycomb, Azure DevOps)
Remove Active Directory groups and users related to the service

Builds, deployments, repositories, and documentation

Archive, disable, or delete build and deployment pipelines.
Update the git repo ReadMe to mention the service is now decommissioned, and archive the git repository.
Archive or delete any wiki pages related to the service.

Conclusion

Decommissioning a service is not free; it takes time and effort to do it properly. The longer you leave it though, the more it will cost you and your company.

When people don’t know what a service is for, they will be hesitant to change or remove it, which can lead to it being left around indefinitely and repeatedly incurring the above mentioned costs. This is true not only for entire apps or systems, but also for individual components and resources. I have seen zombie services more than 15 years old still running in production!

If you are unsure of what a service is for and whether it is still being used, it can take a lot of time to investigate and confirm that it is safe to decommission. So it’s important to invest the time upfront and decommission it as soon as you know it is no longer needed.

The best way to ensure all parts of a service get decommissioned properly is to have a clear process and checklist for doing so. I’ve presented a starting checklist that you can build off of, but it should be customized to fit your company’s processes and infrastructure.

It’s unlikely that the checklist will be perfect on the first try, so be sure to continually update it as you learn from each decommissioning experience.

I hope this article has encouraged you to think about the decommissioning phase of the SDLC, and to hopefully save you and your company from the costs of neglecting it.

Happy decommissioning!

Easily capture terminal output from users you help remotely

Daniel Schroeder — Sun, 01 Mar 2026 00:00:00 +0000

When helping others troubleshoot issues with their PC, you often need to see the output of commands they run. The easiest way to do this is to synchronously video call and screen share, but that’s not always possible.

Below are some alternative asynchronous options for seeing the output of commands they run.

Print Screen

An easy option is to use the PrtSc (or Print Screen) key to capture the whole screen, or Alt + PrtSc to capture just the active window.

This will copy the screenshot to their clipboard, which they can then paste into a Slack or Teams message or email.

A screenshot is nice and easy, unless the entire output does not fit nicely in a single image, or if you want to be able to copy and paste the output yourself.

Terminal command options

To get the output of a command, you can ask them to run the command and copy the output to the clipboard.

Manually copying the output is not always easy though, as many terminals use block selection which is unintuitive and makes it hard to copy the entire output, especially if the output is long and requires scrolling.

Instead, we can simply adjust the command they are running to automatically copy the output to the clipboard or save it to a file, which they can then send to you via Slack, Teams, email, etc.

Capture command output to the clipboard

Simply append | clip to the end of the command to copy the output to the clipboard, preserving the formatting.

For example, instead of just running:

Get-Process

They can run:

Get-Process | clip

This works for the output of any command or executable, not just PowerShell commands. For example:

dsregcmd /status | clip

This works in both PowerShell and the old-school Command Prompt.

In PowerShell, clip is the alias for Set-Clipboard, which is a built-in PowerShell cmdlet that copies input to the clipboard.

There is also a clip.exe executable too, so if you are in WSL or Git Bash, you can use clip.exe to copy the output to the Windows clipboard. e.g.

ps | clip.exe

clip.exe will even work in PowerShell and Command Prompt, so you can always use it in place of clip if you like.

A downside to this method is that the output is not visible in the terminal; it is only copied to the clipboard.

Capture command output to a file

You can use the >> operator to redirect the output of a command to a file. e.g.

Get-Process >> C:\temp\output.txt

In PowerShell, the >> operator is an alias for Out-File, which is a built-in PowerShell cmdlet that writes output to a text file. e.g.

Get-Process | Out-File -FilePath C:\temp\output.txt -Append

The >> operator works in other shells too, like Command Prompt and Bash, so it’s a good one to know.

The >> operator will append the output to the file if it already exists, while using just > will overwrite the file if it already exists. Using >> allows you to run multiple commands and capture all of the output to the same file.

A downside of this approach is the output is not written to the terminal; it is only written to the file.

Capture command output to both the terminal and a file

We can use Tee to see the output in the terminal and save it to a file. e.g.

Get-Process | Tee C:\temp\output.txt

This will write the output to both the terminal and the file.

In PowerShell, Tee is an alias for Tee-Object. The full command syntax could look like this:

Get-Process | Tee-Object -FilePath C:\temp\output.txt

tee exists in other shells as well like Bash, so using the shorthand syntax will work pretty much everywhere. e.g.

ps | tee output.txt

Start a transcript to capture all output from the terminal session

PowerShell has a built-in transcript feature that can capture all output from a terminal session and save it to a file. This is great if you want to capture the output of multiple commands.

To start a transcript, simply run the Start-Transcript cmdlet and specify the path to the file where you want to save the transcript. Then run the various commands you want to capture the output of. When you’re done, run the Stop-Transcript cmdlet to stop the transcript and save the file.

Start-Transcript -Path C:\temp\transcript.txt

# Run various commands here
Get-Process
Get-Service
dsregcmd /status

Stop-Transcript

The transcript text file can then be sent to you via Slack, Teams, email, etc.

This method only works for PowerShell.

Conclusion

While screen sharing is often the best way to interactively help someone and see the output of commands in real time, it’s not always possible. Taking screenshots is easy and effective, except in the case of long outputs that don’t fit on a single screen, or when you want to be able to copy and paste the output yourself.

Luckily, there are several easy options for capturing terminal output to a file or the clipboard, which can then be shared via Slack, Teams, email, etc.

I hope you’ve found this post informative and it helps you when working with others remotely!

Happy helping and troubleshooting! 😊

Colour your kubectl output and type less

Daniel Schroeder — Thu, 05 Feb 2026 00:00:00 +0000

If you work with Kubernetes on the command line using kubectl, you will appreciate kubecolor. Kubecolor is a small utility that adds colour to your kubectl output, making it easier to read and understand at a glance.

Normally when you run a kubectl command, you get back a wall of boring grey text. With kubecolor, you get informative, colourful output like this:

I especially appreciate how errors are highlighted red, making them easy to spot.

Kubecolor installation

Kubecolor is cross-platform, easy to install, and has great installation documentation.

For example, installing it on Windows is as easy as running:

winget install --id Kubecolor.kubecolor

Setup to use kubecolor by default

The Kubecolor documentation also has great setup instructions for many shells, including PowerShell.

You can typically set up an alias so that anytime you run kubectl, it automatically uses kubecolor. Better yet, instead of having to type kubectl every time, just type k instead!

Here’s how you can set that up in PowerShell:

Set-Alias -Name kubectl -Value kubecolor
Set-Alias -Name k -Value kubectl

Now you can run k get pods and see colourful output by default.

Setup kubectl command and parameter completions

The documentation also has instructions for setting up kubectl completions in many shells, which is super handy.

This is how it can be done in PowerShell:

kubectl completion powershell | Out-String | Invoke-Expression
Register-ArgumentCompleter -CommandName 'k','kubectl','kubecolor' -ScriptBlock $__kubectlCompleterBlock

Now you can type k get p and hit Tab and it will auto-complete. Continue hitting Tab to cycle through the available options, or use Ctrl + Space to see all available options.

This works for both command names and parameter values, making it easier to discover kubectl commands and custom resources in your cluster. Try typing each of the following and hitting Ctrl + Space. Note the trailing space at the end of each:

k
k get
k get pods -n

Automatic setup with PowerShell profile

You don’t want to have to run the setup commands every time you open PowerShell though. You can use your PowerShell profile to run the code automatically every time PowerShell starts.

In PowerShell, you can find the path to your PowerShell profile by running:

$PROFILE

To open the file in Notepad, run:

notepad $PROFILE

Create the file if it doesn’t exist, and add the following code to it:

# If kubecolor is installed, alias kubectl to use it.
if (Get-Command kubecolor -ErrorAction SilentlyContinue)
{
  Set-Alias -Name kubectl -Value kubecolor
}

# If kubectl is installed, register the argument completions for kubectl and its aliases.
if (Get-Command kubectl -ErrorAction SilentlyContinue)
{
  Set-Alias -Name k -Value kubectl
  kubectl completion powershell | Out-String | Invoke-Expression
  Register-ArgumentCompleter -CommandName 'k','kubectl','kubecolor' -ScriptBlock $__kubectlCompleterBlock
}

That’s it!

To test it out, open a new PowerShell window and run k version or k get pods. You should see beautiful, colourful output.

Colour themes

Kubecolor comes with several built-in colour themes, including light and dark themes. It even allows you to create your own custom themes. See the documentation for more info.

Conclusion

So now you get beautiful, colourful kubectl output that is easier to read and understand at a glance. You also get to type less by using the k alias, and improve discoverability with command and parameter completions.

I hope you found this useful.

Happy Kuberneting!

If you enjoyed this post, you might also like this post on using Oh My Posh and updating your terminal to use different fonts.

Handy Windows Command Prompt commands

Daniel Schroeder — Sun, 25 Jan 2026 00:00:00 +0000

Below are some handy Windows Command Prompt commands that can help you troubleshoot and manage your system more effectively.

For commands that produce a lot of output, consider redirecting the output to a text file for easier reading. You can do this by appending > filename.txt to the command. Another option is appending | clip when using PowerShell to copy the output directly to the clipboard so you can paste it in a text editor.

Command	Description
chkdsk	Checks the file system for logical and physical errors. Can fix some issues automatically using `/f` or `/r` parameters.
Dism /Online /Cleanup-Image /RestoreHealth	Repairs the Windows image, fixing corruption and other issues that may affect system stability.
gpupdate /force	Forces an immediate update of Group Policy settings. Useful for applying changes without waiting for the next automatic refresh.
ipconfig	Displays the current network configuration, including IP address, subnet mask, and default gateway.
ipconfig /displaydns	Shows the contents of the DNS resolver cache.
ipconfig /flushdns	Clears the DNS resolver cache, which can help resolve certain connectivity issues.
powercfg /batteryreport	Generates a detailed battery report for laptops, showing past usage and battery health.
netstat -anob	Displays active network connections, their ports, and the associated app name and process ID (PID) using the port. Useful for identifying suspicious connections, and finding which application is using a particular port.
sfc /scannow	Scans all protected system files and replaces corrupted files with a cached copy.
whoami	Displays the current logged-in user name along with domain information.
whoami /groups	Lists all the groups the current user belongs to.
winget upgrade	Lists all installed applications that have available updates via Windows Package Manager.
winget upgrade –all	Upgrades all installed applications that have available updates via Windows Package Manager.
wmic product get name	Lists all installed software on the system. Useful for inventory or troubleshooting purposes.
wmiobject win32_winsat	Displays the Windows System Assessment Tool (WinSAT) scores, which provides hardware performance scores to quickly see a PCs overall performance.

I intend to keep updating this list as I discover more useful commands. If you know of others, please let me know in the comments.

If you like these, you might also like my Common Run commands to access various Windows settings and apps post.

I hope you find these helpful. Happy computing!

Logitech MX Master 4 vs 3s comparison by a 40 something year old

Daniel Schroeder — Sat, 06 Dec 2025 00:00:00 +0000

Ever since I got the Logitech MX Master 3s in December 2023, it’s been my favourite mouse of all time, beating out my previous favourites from the 2000s, the Logitech MX510 and later the Logitech MX518, both discontinued (although there’s a newer reincarnated MX518 now).

But this isn’t about those mice; it’s about the Logitech MX Master 4, which was released in October 2024, and how I found it compared to the MX Master 3s.

This is not meant to be a comprehensive review; just my personal experience and what stood out to me.

Why I got the MX Master 3s

I’ve been using the Logitech MX Master 3s for almost 2 years now. I got it because I started having wrist pain, and thought a more ergonomic mouse might help.

I first tried the Logitech MX Vertical, but didn’t like how I had to move my entire arm to move the mouse. I then tried the MX Master 3s. It was super comfortable, had all of the essential buttons (left, right, middle, back, forward, and scroll wheel), as well as a thumb wheel and gesture thumb button. I loved that all of the buttons were programmable too, via the Logi Options+ app. The thumb gesture button allows you to click it, as well as hold it and move the mouse up/down/left/right to trigger actions, so I have mine configured to control my media (play/pause, volume up/down, next/previous track).

After using it for a couple weeks my wrist pain went away, and I had a new favourite mouse!

Let my pain be a lesson kids. Invest in an ergonomic mouse and keyboard now, before you develop problems!

A common problem with the MX Master 3s

I love the MX Master 3s. After almost 2 years though, it started having flaky issues with left button clicks. Sometimes it would not register single clicks, or would double-click when I only clicked once. It also made dragging-and-dropping very difficult, as most times it would release the drag before I let go of the button.

After some research, I found that this is a common issue with the MX Master 3s and the typical fix is to replace the button switch (as shown in this YouTube video), which requires taking the mouse apart and soldering. While I like to imagine myself as a DIY guy, I’ve never soldered before and don’t have the tools on hand.

Instead, I took the mouse apart and applied a couple pieces of tape to the mouse casing above the switch to increase the tension on it (also shown in the above YouTube video). This helped a bit and the issues were less frequent, but didn’t totally fix the issue. A week later I also applied a drop of WD-40 to the switch, as mentioned on Reddit. This has my 3s working normally again, at least for now.

Trying out the MX Master 4

Since the MX Master 4 had just come out, I figured it was a good time to upgrade, as I wasn’t sure how long my temporary fix to my 3s would last.

Unfortunately, it sounds like the MX Master 4 uses the same button switches as the 3s, so they will likely have the same issue eventually. Time will tell.

Below is a breakdown of how I found the MX Master 4 compared to the 3s.

✅ MX Master 4 Pros :

I like the thumb wheel better. It sits closer to the tip of my thumb, making it more comfortable to use.
Has an extra programmable gesture button in front of the forward button, which was a compelling reason to upgrade.
The haptic feedback (vibration) is neat, but not really useful. The only time I notice it is when waking the mouse and using the Actions Ring. Right now very few apps make use of it, but that may change in the future.
Screws to take it apart do not require removing the feet pads, like the 3s.
- Uses 6 phillips screws, which is nice. The 3s uses 5 phillips screws and 1 torx screw, which was annoying as I had to hunt down a torx screwdriver.
Feels very similar to the MX Master 3s in terms of shape, size, and button layout, and uses the same Logi Options+ app, so upgrading felt smooth.

❌ MX Master 4 Cons :

It feels quite a bit heavier than the 3s. The specs say it’s only 9 grams heavier (150g vs 141g), but it feels like more.
- I was getting wrist pain a couple years back, and the 3s alleviated that for nearly 2 years. After using the 4 for a little over a week, the wrist pain returned.
The thumb button is triggered by pressing down or in, so I often press it in by accident when adjusting the mouse new position on my desk, such as when changing my sitting position.
- In the 3s, you have to press the thumb button down, allowing you to easily pick up the mouse (by squeezing your thumb in) without accidentally pressing the button.
- The 4 is both heavier and smoother than the 3s. Even with the textured bumps on the thumb button, it’s quite slippery, making the thumb slide when picking it up and forcing you to grip it tighter, leading to accidental presses.
- I found this mentioned in several other online reviews as well, so I know it’s not just me.
- I change the thumb button to media controls (the default action is the Actions Ring), so more than once I accidentally pressed the thumb button while adjusting the mouse position on my desk and started playing music while on a video call (embarrassing! 🫠).
The gesture button is so far forward it’s a bit hard to reach with my thumb.
- It’s not a huge issue, but I noticed myself having to consciously think about reaching for it. That could change and become muscle memory over time though.
The scroll wheel button to switch between ratchet and free-spin modes makes a noticeable click sound, where it is silent on the 3s. This doesn’t really bother me though; just something I noticed.

The feel of the MX 4 in my hand is very similar to the 3s. The 3s is a bit grippier due to the rubberized surface, while the MX 4 has a smoother plastic finish. I didn’t mind the feel, but considering the MX 4 is heavier, it could have benefitted from the grippier surface. The shape is nearly identical, with only very minor differences.

If I didn’t feel them side-by-side, it would be hard to tell which is which, aside from the weight difference and the feel of the thumb button. If you like the feel of the MX 3s, you’ll likely like the MX 4 as well.

I’ll note that I use Bluetooth for both, so I can’t comment on the performance of the included Logi Bolt USB receiver. I can say though that the 3s uses a USB-A port, while the 4 uses USB-C, so you may need to consider how many open ports you have.

Also, while I have used both mice for video games, I don’t play competitive or fast-paced games where low millisecond response times make a difference. Both mice perform completely fine for my casual gaming needs. Others have commented that if you need high polling rates, neither of these mice are ideal and you should invest in a proper gaming mouse.

Here’s a few pics to visually compare the two, with the 3s being the black one (bottom/left) and the 4 the graphite (grey) one:

Conclusion

While I quite liked the MX Master 4, especially for the extra programmable button, the wrist pain due to increased weight and accidental thumb button presses were a deal-breaker for me.

I ended up returning my MX Master 4 and will likely be ordering another 3s if the click issues return. If I was still in my 20s and hadn’t developed wrist pain, I likely would have kept the MX 4.

If Logitech releases a followup version that’s a bit lighter and addresses the accidental thumb button presses, I would try it out again.

I don’t often do product reviews or comparisons, so if you enjoyed this leave a comment and let me know!

Should observability replace custom error messages?

Daniel Schroeder — Sun, 19 Oct 2025 00:00:00 +0000

Open Telemetry (OTEL) and observability tools have come a long way in recent years. They can provide a wealth of information about what your application was doing when an error occurred. But can they replace good custom error messages that provide additional context about what went wrong?

Background

Dave Callan, a fellow Microsoft MVP, recently asked on LinkedIn if .NET developers prefer to use .First(), .FirstOrDefault(), .Single(), or .SingleOrDefault() when they expect exactly one item in a collection.

I’ve written about this very subject, so I commented with a link to my blog post where I state that I prefer to always use .FirstOrDefault() because it allows me to provide a descriptive custom error message, which can make troubleshooting much easier.Dave replied that he prefers to use .Single(), even though it gives a generic error message, and rely on observability tools to troubleshoot issues when they arise; especially for issues that “should never happen”.

This got me thinking about whether observability tools can truly replace good custom error messages.

Observability is awesome

If you’re not familiar with OpenTelemetry (OTEL), it’s a standard set of APIs for collecting metrics, traces, and logs from your application, giving you observability into its behavior. You create spans to track how long an operation takes, and add attributes to those spans to provide additional context. The attributes can be things specific to the operation, such as the user or items involved in the operation, or more general information, such as the environment, version of the application, or the operating system it’s running on.

You then export the OTEL data into an observability tool, which allows you to visualize and query the data. This allows you to answer questions like:

Which company, user, or region has the most failed requests this week?
What is the average response time for requests to a specific endpoint? Which endpoints are the slowest?
What do failing requests have in common? e.g. a specific user, company, server, region, browser, app version, etc.
What were the headers, parameters, or payload of a specific request?

It also allows for distributed tracing, letting you see how individual requests flow through your application and its dependencies (e.g. other services, database calls, etc.), allowing you to pinpoint where things went wrong or spot potential bottlenecks between components.

There’s no question that adding OTEL instrumentation to your application can provide valuable insights into its behavior. It provides additional information, allowing you to troubleshoot issues and spot trends before they become problems. When possible, you should absolutely add OTEL instrumentation to your application.

Should observability replace custom error messages though?

To be clear, I’m not talking about simply catching an exception and rewriting it with a more user-friendly message. I’m talking about including specific data that may have led to the error, such as the parameter values that were used, the dataset that was being queried, or any other relevant context that could aid in troubleshooting.

Here’s some typical code that would throw an exception with a generic error message:

var people = new List<string> { "Alfred Archer", "Billy Baller", "Billy Bob", "Cathy Carter" };
var name = "Zane";

// Throws generic exception: System.InvalidOperationException: Sequence contains no matching element
var zane = people.First(x => x.StartsWith(name));

And modified code that provides a more descriptive custom error message:

var people = new List<string> { "Alfred Archer", "Billy Baller", "Billy Bob", "Cathy Carter" };
var name = "Zane";

try
{
    var zane = people.First(x => x.StartsWith(name));
}
catch (InvalidOperationException ex)
{
    throw new PersonNotFoundException($"Could not find a person named '{name}' in the people list.", ex);
}

Notice that the custom error message provides the name of the person that was being searched for, which can be tremendously helpful when troubleshooting. It makes it easy to know the exact name, and verify there were no typos or unexpected characters. e.g. They searched for “ Zane “ (with spaces), or “Zone” instead of “Zane”.

Be mindful to not include sensitive information in error messages, such as passwords or personal data.

We could have also added OTEL instrumentation to the code, creating a span for the operation and adding attributes for the name being searched for.

Even if we had added OTEL instrumentation, I would argue that custom error messages are still valuable for a number of reasons:

Quicker troubleshooting

Custom error messages can provide immediate context about what went wrong, and can be surfaced in different ways:
- Shown in the observability tooling.
- Logged in application logs (local or remote), separate from the observability tooling.
- Displayed to the user, if appropriate.
Allows developers to identify problems faster, as they don’t need to query the observability tooling and follow breadcrumbs to find the relevant information.
Potentially allows users to self-serve and resolve issues on their own, if the error message is displayed to them.
- If a user presses a button to submit a form and sees the error message “System.InvalidOperationException: Sequence contains more than one matching element”, they may not know what to do. However, if they see “Error: More than one user found with the email address ‘me@example.com’”, they have a clearer understanding of the issue and can potentially resolve it themselves.
- Allowing users or support staff to resolve issues on their own saves both users and developers time, making everyone happier.

Do observability tools have the data you need?

Observability tooling relies on the data that is sent to it. If the necessary data is not being captured, it may not be available when you need it.
Custom error messages can provide additional context only when its needed.
- For example, a custom error message may include the parameters that were used for a specific query, or the dataset that was being queried, whereas you may not want to log that information for every request in your observability tooling.
Do you have every component in the chain instrumented?
- If your application calls an external service or third-party library that is not instrumented, it may not have the necessary data to help troubleshoot an issue.

Budgets change, or are non-existent

Observability tooling can be expensive, and not all organizations have the budget for it.
Even if your organization has the budget now, it may not in the future.
Many organizations implement sampling to reduce costs (e.g. only retain 20% of traces), which means you may not have the necessary data to troubleshoot a specific issue.

Access to observability tooling

Not all developers may have access to the observability tooling, especially in larger organizations, or where you pay per user.
- Does every team member have access to the tooling? What about support staff?

Team members change

Do all team members know how to effectively use the observability tooling?
- Team members who are familiar with the tools may leave the organization.
- New team members may not be familiar with the observability tools, know where to find them, or even know they exist.

Observability tooling changes

Organizations may change observability providers (e.g. New Relic to Datadog to Honeycomb to …), which means team members may need to learn new tools.
Have all of the old apps and services been updated to send data to the new observability provider?

Aside: I’m a huge fan of Honeycomb.io.

The type of application matters

Do users expect a desktop/mobile application to be sending observability data over the network?
If not stored remotely, do users expect your app to store all of that observability data locally?
Users may not want an application to send or store observability data at all, due to privacy, data usage, or performance concerns.

Conclusion

It probably seems obvious that it’s preferable to include information in the error message that can help troubleshoot the issue. I can’t tell you though how many times I’ve been frustrated, both as a user and as a developer, by generic error messages that provide no context about what went wrong.

I’m of the opinion that the more information you can provide when an error occurs, the better. There’s no doubt that observability can provide additional information that can help troubleshoot issues. However, there’s no guarantee that it will provide the same information that a well-crafted custom error message can provide, or that the observability data will be available when you need it.

A developer spending an extra couple of minutes writing a custom error message that provides additional context can save hours, even days, of troubleshooting time later on. Even if it’s not an error message the end-user will see, it can still be tremendously helpful for developers and support staff.

So the next time you’re performing an operation that may potentially throw an exception, consider whether catching and re-throwing the exception with additional context information may be beneficial.

Happy coding!

My favourite Windows shortcuts

Daniel Schroeder — Wed, 24 Sep 2025 00:00:00 +0000

Windows has a ton of keyboard shortcuts that can help you be more efficient. Below are some of my favourites.

Note that Win is the Windows key.

If you enjoy this post, check out my Windows settings I change after a clean install post.

Windows shortcuts

You can use the following shortcuts regardless of the application you’re in:

Alt + Tab: Cycle between open windows.
Alt + Shift + Tab: Cycle between open windows in reverse.
Win + Up: Maximize the current window.
Win + Down: Restore / Minimize the current window.
Win + Left / Right: Snap the current window to the left or right side of the screen.
Win + Shift + Left / Right: Move the current window to the left or right monitor (only works with multiple monitors set up).
Win + Alt + Left / Right / Up / Down: Snap the current window to a specific quadrant of the screen (Windows 11 only).
Win + Tab: Open Task View to see all virtual desktops and all windows in the current virtual desktop.
Win + Ctrl + D: Create a new virtual desktop.
Win + Ctrl + Left / Right: Switch between virtual desktops.
Win + D: Minimize all windows; press again to restore all windows.
Win + E: Open File Explorer.
Win + R: Open the Run dialog.
Win + P: Open the Project menu (for connecting to external displays).
Win + I: Open Settings.
Win + L: Lock the computer.
Ctrl + Shift + Esc: Open Task Manager.
Win + A: Open the Action Center.
- Contains controls for Wi-Fi, Bluetooth, Airplane mode, volume, brightness, and more.
Win + X: Open the Quick Link menu.
- Contains links to many system tools, such as Installed Apps, Device Manager, Sign out, Shut down etc.
- I often use Win + X followed by A to open an elevated terminal window.
Win + Period, or Win + Semicolon: Open the emoji picker 🤩.
- Once in the emoji picker, type to search, use Shift + Arrow keys to navigate, Enter to insert the emoji, and Esc to close the picker.
Win + V: Open Clipboard history to paste things copied in the past.
- It’s nice that this is built into Windows 10+, but I prefer to use Ditto Clipboard Manager instead. See my YouTube video on using Ditto, and the followup video showing more features.
Win + Shift + S: Take a screenshot of part of the screen and edit it with the Snipping Tool.
- I prefer to use ShareX instead, which has many more features.
- Windows 11 has greatly improved the Snipping Tool, including adding shapes to the image editor and the ability to take video as well. It is a great built-in option if you don’t want to install a third-party app.
- On Windows 10 I would recommend Greenshot if you don’t want all of the advanced features of ShareX.
Ctrl + Shift + Win + B: Restart the graphics driver.
- This is useful if your screen is not drawing properly or one of your monitors stops displaying.

Applications that support multiple tabs (e.g. web browsers, text editors, File Explorer on Windows 11+) often support:

Ctrl + Tab to cycle between tabs in the application.
Ctrl + Shift + Tab to cycle between tabs in reverse.

The functionality may vary depending on the application though.

Taskbar shortcuts

The taskbar is the bar typically at the bottom of the screen that contains the Start button, pinned applications, open windows, and the system tray. There are a few shortcuts you can use when clicking on an application in the task bar:

Shift + Left-click: Opens another instance of the application.
Ctrl + Shift + Left-click: Opens another instance of the application as an administrator.
Shift + Right-click: Show additional context menu options, such as Run As Admin or a Different User.

File Explorer shortcuts

When in the File Explorer, you can use the following shortcuts:

Alt + Up: Go up one level in the folder hierarchy.
Alt + Left: Go back.
Alt + Right: Go forward.
Ctrl + N: Open a new File Explorer window at the current folder.
Ctrl + T: Open a new tab (Windows 11+).
Ctrl + Shift + N: Create a new folder.
Alt + D: Focus the address bar so you can type in it.
Alt + Enter: Show properties for the selected file/folder.
F2: Rename the selected file/folder.
Shift + Delete: Permanently delete the selected items without moving them to the Recycle Bin.
Ctrl + A: Select all items in the current view.
Hold Shift and click to select a range of items.
Hold Ctrl and click to select multiple individual items.
Just start typing the name of a file or folder to quickly jump to and select it.

Many of the above shortcuts also work in other applications, such as web browsers and text editors.

In the File Explorer address bar (or the Run dialog window), you can type:

cmd to open a command prompt in the current folder.
pwsh to open a PowerShell 7+ prompt in the current folder, if you have it installed.
shell:startup to open the Startup folder of the current user.
- Placing a shortcut to an application in this folder will make it start automatically when you log in.
shell:sendto to open the SendTo folder of the current user.
- Placing a shortcut to an application in this folder will make it appear in the Send To context menu when you right-click a file or folder.
shell:common startup to open the Startup folder for all users.
shell:common sendto to open the SendTo folder for all users.
shell:desktop to open the Desktop folder.
shell:downloads to open the Downloads folder.
shell:appsfolder to see all installed applications, including hidden ones, and right-click to uninstall ones you don’t need.

See my YouTube video on File Explorer shortcuts for more!

Conclusion

Learning and using keyboard shortcuts can significantly improve your productivity. Try to incorporate a few of these shortcuts into your daily routine.

As I discover more great shortcuts I'll update the original canonical post, so be sure to check it for updates!

Know of a great shortcut that I missed? Please let me know in the comments!

Create an Azure app registration secret with expiry longer than 24 months

Daniel Schroeder — Fri, 01 Aug 2025 00:00:00 +0000

The Azure portal allows you to create app registration secrets with a maximum expiry of 24 months. This follows the security best practice of forcing you to rotate secrets regularly to minimize the risk of exposure. However, there are scenarios where you might want a secret that lasts longer than this limit.

NOTE: Using long-lived secrets can increase the risk of exposure, so it’s typically not recommended for production applications. Especially for secrets that would grant access to sensitive resources or data, or that have high privileges. A better approach is to use short-lived secrets and automate rotating them regularly. Even better, use Federated Identity Credentials and avoid secrets and expirations altogether.

To create an Azure app registration (i.e. service principal) secret with an expiry longer than 2 years, you can use the Azure CLI. Here’s an example command that creates a secret with a 5 year expiry, where <application-id> is the Application (Client) ID of your app registration:

az ad app credential reset --id <application-id> --years 5

This will create a new secret on the app registration and output the password, which is the secret value. Be sure to copy the value and store it somewhere secure, such as an Azure Key Vault, as you will not be able to retrieve it again.

You can do the same operation in PowerShell using the Az PowerShell module (specifically the Az.Resources module) and the New-AzADAppCredential cmdlet, but you must use the app registration’s Object ID instead of the Application ID:

$startDate = (Get-Date)
$endDate = $startDate.AddYears(5)
New-AzADAppCredential -ObjectId <object-id> -StartDate $startDate -EndDate $endDate -DisplayName 'User friendly description'

Hopefully you (and my future self) find this helpful.

Happy coding!

My favourite git aliases

Daniel Schroeder — Wed, 02 Apr 2025 00:00:00 +0000

Git is super powerful, but can also be confusing, especially when using the command line interface (CLI). It has so many commands, and I only regularly use a handful of them.

To make it both easier to remember commands I rarely use, and to reduce the number of keystrokes needed to execute the ones I use all the time, I use Git aliases.

Show me the code!

I go over each alias in detail below, but here’s the alias section taken directly from my current global .gitconfig file in my user directory. e.g. C:\Users\[Your Name]\.gitconfig on Windows, or ~/.gitconfig on Linux/Mac.

[alias]
  alias = !echo 'git config --get-regexp ^alias\\.' && git config --get-regexp ^alias\\.
  ac = !echo 'git add -A , git commit -m' && git add -A && git commit -m
  b = !echo 'git branch' && git branch
  browse = !echo 'start `git config get remote.origin.url`' && start `git config get remote.origin.url`
  co = !echo 'git checkout' && git checkout
  commit-empty = !echo 'git commit --allow-empty -m \"chore: Empty commit to re-trigger build\"' && git commit --allow-empty -m \"chore: Empty commit to re-trigger build\"
  delete-local-branches-already-merged-in-remote = !echo 'git branch --merged | egrep -i -v(main|master|develop|dev|staging|release)| xargs -r git branch -d' && git branch --merged | egrep -i -v '(main|master|develop|dev|staging|release)' | xargs -r git branch -d
  delete-local-branches-already-merged-in-remote-what-if = !echo 'git branch --merged | egrep -i -v(main|master|develop|dev|staging|release)//| xargs -r git branch -d' && git branch --merged | egrep -i -v '(main|master|develop|dev|staging|release)'
  delete-local-tags = !echo 'git tag -l | xargs git tag -d && git fetch --tags' && git tag -l | xargs git tag -d && git fetch --tags
  delete-stale-remote-tracking-branches-from-local = !echo 'git remote prune origin' && git remote prune origin
  ge = !echo 'GitExtensions .' && GitExtensions .
  gec = !echo 'GitExtensions commit' && GitExtensions commit
  gtfo = !echo 'git reset --hard , git clean -xfd' && git reset --hard && git clean -xfd
  history = !echo 'git log --oneline --graph --decorate --all' && git log --oneline --graph --decorate --all
  s = !echo 'git status' && git status
  pushf = !echo 'git push --force-with-lease' && git push --force-with-lease
  pushnew = !echo 'git push --set-upstream origin branch_name' && git push --set-upstream origin `git symbolic-ref --short HEAD`
  stashall = !echo 'git stash push --include-untracked' && git stash push --include-untracked

You will notice that each alias begins with !echo '...' &&. This is not mandatory and you can remove it if you like; it will simply print the command to the console before executing it, so that you can see the actual commands being run.

For brevity, I will not include the !echo '...' && part in the explanations below.

Updating your .gitconfig file

To add these aliases to your global .gitconfig file, you can either:

Use the git config command to add them one by one.
- For example, to add the ac alias, you can run the following command in your terminal:
To mass edit, open the file in a text editor and add them manually.
- To open the file in the default editor, use the following command:

Individual aliases in detail

alias = git config --get-regexp ^alias\\.

Typing git alias will show you all the aliases you have set up in your .gitconfig file.

ac = git add -A && git commit -m

Typing git ac "The commit message" will add all changes to the staging area and commit them with the provided message.

b = git branch

Typing git b will show you all the branches in your local repository. This alias just saves a few keystrokes.

browse = start `git config get remote.origin.url`

Typing git browse will open the remote repository in your default web browser.

Tip: Use this to open the repository in GitHub, Azure DevOps, Bitbucket, etc. to create pull requests after committing changes to a branch and pushing them up, if you prefer the PR creation web experience to the IDE experience.

Note: start is a Windows command to open a file or URL in the default application. You may need to adjust this for the Linux/Mac equivalent, which is may be open for Mac and xdg-open for Linux.

co = git checkout

Typing git co branch_name will switch to the specified branch. This alias just saves a few keystrokes.

commit-empty = git commit --allow-empty -m \"chore: Empty commit to re-trigger build\"

Typing git commit-empty will create an empty commit with the message chore: Empty commit to re-trigger build. This is useful for re-triggering builds in CI/CD pipelines without making any code changes.

delete-local-branches-already-merged-in-remote = git branch --merged | egrep -i -v '(main|master|develop|dev|staging|release)' | xargs -r git branch -d

Typing git delete-local-branches-already-merged-in-remote will delete all local branches that have already been merged into the remote repository, except for the specified branches (main, master, develop, dev, staging, release). This is useful for cleaning up your local branches after merging pull requests.

Tip: Change the branches in the egrep command to match your own branch names that you never want it to delete.

Tip: If you don’t like the long verbose alias name, give it a new one! 😊

delete-local-branches-already-merged-in-remote-what-if = git branch --merged | egrep -i -v '(main|master|develop|dev|staging|release)'

Typing git delete-local-branches-already-merged-in-remote-what-if will show you all local branches that would be deleted if you ran the delete-local-branches-already-merged-in-remote alias command.

delete-local-tags = git tag -l | xargs git tag -d && git fetch --tags

Typing git delete-local-tags will delete all local tags and fetch the latest tags from the remote repository, ensuring that your local tags exactly match the remote’s.

delete-stale-remote-tracking-branches-from-local = git remote prune origin

Typing git delete-stale-remote-tracking-branches-from-local will delete any stale remote-tracking branches from your local repository. That is, if a branch has been deleted from the remote repository, this will remove it from your local repository as well if needed.

ge = GitExtensions .

Typing git ge will open the GitExtensions GUI for the current repository. This requires having GitExtensions installed on your machine.

I use this when I’m not in an IDE, like VS Code, and want to view the history of branches and view their commits and diffs.

Tip: If you prefer a different git tool over GitExtensions, you may be able to replace GitExtensions with the name of your preferred tool.

gec = GitExtensions commit

Typing git gec will open the GitExtensions GUI for committing changes in the current repository. Again, this requires having GitExtensions installed on your machine.

I use this when I’m in the terminal and want a more rich and easy diff, stage, and commit experience than the command line provides.

Tip: Again, if you prefer a different git tool over GitExtensions, you may be able to use it if it accepts command line arguments.

gtfo = git reset --hard && git clean -xfd

Typing git gtfo will reset your current branch to the last commit, deleting any uncommitted changes and removing all untracked files and directories.

history = git log --oneline --graph --decorate --all

Typing git history will show you a more compact representation of the commit history for all branches in your repository.

Here is a sample output of the git history alias:

Compare that to the default git log output:

s = git status

Typing git s will show you the status of your current branch, including any uncommitted changes and the current branch name. This alias just saves a few keystrokes.

pushf = git push --force-with-lease

Typing git pushf will force push your changes to the remote repository, with a lease. This is useful when you need to overwrite the remote branch with your local changes, but you want to ensure that you don’t accidentally overwrite someone else’s changes by forgetting to add --force-with-lease.

pushnew = git push --set-upstream origin `git symbolic-ref --short HEAD`

Typing git pushnew will push your current branch to the remote repository and set the upstream branch to the same name. This is useful when you create a new branch locally and want to push it to the remote repository for the first time, and aren’t using an IDE that does this for you. This is similar to the git push --set-upstream origin branch_name command, but it automatically uses the name of the current branch.

stashall = git stash push --include-untracked

Typing git stashall will stash all changes in your working directory, including untracked files. This is useful when you want to temporarily save your changes without committing them, and you want to include untracked files as well.

Why aren’t you using PowerShell commands in the alias?

I’m a huge proponent of PowerShell, so you may be wondering why I’m using unix commands like xargs and egrep in my aliases. The main reason is that PowerShell is not installed by default on Linux and Mac. Git Bash is installed with Git though, so I believe the aliases should work on all platforms and in non-PowerShell shells.

Conclusion

I use these aliases to make my life easier when working with Git on the command line. Hopefully you’ve found some of them useful, or they’ve inspired you to create new ones not listed here. Feel free to customize these aliases to fit your preferences.

If you have suggestions for other aliases, please leave a comment below! If you found this post helpful, consider sharing it with friends and colleagues.

Happy coding!

Reclaim disk space by cleaning all your Git repos with PowerShell

Daniel Schroeder — Mon, 17 Feb 2025 00:00:00 +0000

Developers often have tens or hundreds of Git repositories on their machines. When we are done with a project, we often forget to clean up the repository, leaving temporary files like build artifacts, logs, packages, modules, and other files taking up valuable disk space.

The git clean command can be used to remove untracked files and free up disk space. However, running git clean -xfd in each repository manually can be a hassle. Luckily, we can automate this process using PowerShell.

Clean all repos using the GitClean PowerShell module

To make it easy to clean all your Git repositories, I created the cross-platform GitClean PowerShell module.

Assuming all of your Git repositories are located under a common root folder, C:\dev\Git for example, you can install the module and clean all your repos with the following PowerShell code:

Install-Module -Name GitClean
Invoke-GitClean -RootDirectoryPath 'C:\dev\Git'

In the screenshot above you can see it found 262 Git repositories, cleaned 260 of them, skipped cleaning 2 of them because they had untracked files that would have been lost, and freed up 33.4 GB of disk space. Easy 😊

No more node_modules of old projects taking up all my disk space 😅

Alternative PowerShell one-liner

Not everyone likes installing modules on their system, so as an alternative, here is a simple PowerShell script you can run to clean all your Git repositories:

[string] $rootDirectoryPath = 'C:\dev\Git'

# Find all '.git' directories below the given path.
Get-ChildItem -Path $rootDirectoryPath -Recurse -Depth 3 -Force -Directory -Filter '.git' |
    # Get the directory path of the Git repository.
    ForEach-Object {
        $gitDirectoryPath = $_.FullName
        $gitRepositoryDirectoryPath = Split-Path -Path $gitDirectoryPath -Parent
        Write-Output $gitRepositoryDirectoryPath
    } |
    # Only include Git repositories that do not have untracked files.
    Where-Object {
        $gitOutput = Invoke-Expression "git -C ""$_"" status" | Out-String
        [bool] $hasUntrackedFiles = $gitOutput.Contains('Untracked files')
        if ($hasUntrackedFiles) {
            Write-Warning "Skipping Git repository with untracked files: $_"
        }
        Write-Output (-not $hasUntrackedFiles)
    } |
    # Clean the Git repository.
    ForEach-Object {
        Write-Output "Cleaning Git repository: $_"
        Invoke-Expression "git -C ""$_"" clean -xdf"
    }

You can download this snippet as a script here.

This won’t give you the nice progress bars and detailed information that the GitClean module does, but it will get the job done.

Conclusion

It’s easy to forget to clean up old Git repositories. When you do remember to, the GitClean module can make it quick and painless. You might even want to create a scheduled task or cron job to run it automatically every month to keep your disk space in check.

I hope you find this module useful. Happy coding! 😊

Windows settings I change after a clean install

Daniel Schroeder — Sat, 08 Feb 2025 00:00:00 +0000

Windows has a ton of native settings and features that can make it more pleasant and efficient to use. Below are some of my favorites that I always adjust after a fresh install of Windows. These are all personal preference, and I show the settings I like, but use whatever works best for you.

This post was written with Windows 11 in mind, so some of the settings may not be available in other versions of Windows, or you may need to access them differently.

As I discover more awesome settings I’ll add them to the canonical post here, so be sure to check there from time to time. Also, if you have a favourite that I don’t have listed here, please let me know in the comments below.

If you enjoy this post, check out my My favourite Windows shortcuts post.

File Explorer settings

Have File Explorer open to the This PC view

By default, File Explorer opens to the Home view, which shows a bunch of things, such as your most used folders and files. I find that view very cluttered, and often just want to get into the root of one of my drives, so I prefer to start at the This PC view.

Below are screenshots of the default Home view and the This PC view:

To change the default view of File Explorer to This PC:

In the Start Menu, search for File Explorer Options and open it.
In the File Explorer Options window, change the Open File Explorer to setting to This PC.

Show hidden files and folders and file extensions in File Explorer

By default, File Explorer will not show hidden files and folders, nor show file extensions for known file types. I don’t like Windows hiding things from me, so I always enable these settings.

Below are screenshots showing how a directory in File Explorer might look before and after making the changes:

To enable the settings:

Open File Explorer Options.
- You can search for File Explorer Options in the Start Menu, or find it in File Explorer by clicking the View tab, then Options on the right side (Windows 10), or the ... button then Options (Windows 11).
In the Folder Options window, click on the View tab.
Under Advanced settings, find the following settings:
- Enable Show hidden files, folders, and drives
- Disable Hide extensions for known file types
Click Apply to apply it to the current folder.
Click Apply to Folders to apply it to all folders.

The last step of clicking the Apply to Folders button is important so that you don’t have to do this for every folder you open.

Mouse settings

Show where the mouse cursor is with the Ctrl key

If you have multiple monitors, it’s easy to lose the mouse cursor. Windows has a feature that when you press the Ctrl key, it will show you where the mouse cursor is by briefly circling it.

To enable this feature:

Use the Start Menu to search for Mouse settings.
In the Mouse settings window, open the Additional mouse settings, which should pop up the Mouse Properties window.
Click on the Pointer Options tab.
Enable Show location of pointer when I press the CTRL key.

Bonus: See the Microsoft PowerToys section at the end to allow spotlighting the mouse cursor when you press the Ctrl key twice.

Make the mouse cursor larger and change the color

Having a large resolution on a small monitor can make it difficult to see the mouse cursor. I like to enlarge my cursor a bit, and change the color to make it stand out so it’s easier to see.

To adjust your mouse cursor settings, use the Start Menu to search for Mouse pointer size. There you can adjust the size and color of the mouse cursor.

Disable the Touchpad when using a mouse

When using Windows on a laptop without an external keyboard, I sometimes accidentally touch the touchpad while typing, which causes the cursor to jump around. To prevent this, I disable the touchpad when a mouse is connected.

To disable the touchpad when a mouse is connected:

Use the Start Menu to search for Touchpad settings.
Expand the Touchpad section.
Uncheck Leave touchpad on when a mouse is connected.

Change Touchpad triple-tap to middle-click

By default Windows opens the Windows search when you triple-tap the touchpad. That’s what the Windows key is for. Instead, I prefer to have the triple-tap act as a middle-click.

To change the touchpad triple-tap to middle-click:

In the touchpad settings window, expand the Three-finger gestures section.
Change the Taps dropdown to Middle mouse button.

Taskbar settings

The Windows taskbar has many settings that can be adjusted.

To open the taskbar settings window:

Right-click on the taskbar and choose Taskbar settings, or you can search the Start Menu for Taskbar settings.

Hide the search box from the taskbar

When I want to search, I use the Win key and start typing, so I don’t like the search box taking up space on the taskbar.

In the taskbar settings window, in the Taskbar items section, change the Search to Hide.

Hide the task view button

I don’t use multiple task views, and use Alt + Tab to switch between windows, so I hide the task view button. You can also use Win + Tab to open the task view.

In the taskbar settings window, in the Taskbar items section, toggle the Task view to Off.

Disable widgets

I don’t use the widgets on the taskbar and find them distracting, so I disable them.

In the taskbar settings window, in the Taskbar items section, toggle the Widgets to Off.

Decide which system tray icons to always show

The system tray is the area on the right side of the taskbar where you can see the time, volume, network status, and other system icons. There are some tray icons that I always want to see, and others that I don’t care about. You can control which ones are always shown, and which ones are hidden behind the Show hidden icons button to save space on the taskbar.

In the taskbar settings window, expand the Other system tray icons section, then toggle On the apps that you want to always show, and Off the ones to hide.

You can also simply drag-and-drop the system tray icons to/from the hidden area to control which ones are always shown.

Shift the Start Menu to the left

Windows 11 moved the Start Menu to the center of the taskbar by default. I prefer the previous Windows behaviour where it was on the left.

In the taskbar settings window, in the Taskbar behaviors section, change the Taskbar alignment to Left.

Never group taskbar buttons

I like to see all of my taskbar buttons including their labels, so I disable grouping them so it’s easy to see which ones are open and quickly select the one I want.

Here is a screenshot of the taskbar with the buttons combined:

And the same taskbar with the buttons not combined:

In the taskbar settings window, in the Taskbar behaviors section, change the Combine taskbar buttons and hide labels to Never.

Enable End Task on right-clicking taskbar icons

Typically when an application hangs, you need to open the Task Manager to kill the app. You can enable End Task in the right-click context menu of taskbar icons to make it easier to kill unresponsive apps.

To enable End Task on right-clicking taskbar icons, go to Settings > System > For developers and enable End Task.

Desktop settings

Change your desktop background image

By default Windows will often display a different desktop background image each day from Bing. I actually quite like this functionality for my personal computer, but prefer to have a static image on my work computer where I often do screen sharing. You may also want to adjust the desktop image if you remote desktop to other computers regularly, so that it’s easy to tell when you are working on your local computer or a remote one.

To change the desktop background image:

Right-click on the desktop and choose Personalize.
In the Personalization settings window, click on Background.
1. You could also get here by searching the Start Menu for Background image settings.
In the Personalize your background section, choose Picture from the dropdown.
1. If you want to cycle through multiple images, you can choose Slideshow instead.
Click the Browse button to select a picture or directory from your computer.
You may want to change the Choose a fit setting to Fill, Fit, or Stretch to make the image look better on your screen.

Turn transparency effects off

I don’t like transparency in my windows and menus, and you get a small performance boost by disabling it.

To disable transparency effects:

Right-click on the desktop and choose Personalize.
In the Personalization settings window, click on Colors.
Toggle the Transparency effects switch to Off.

Power settings

Don’t turn off the screen and go to sleep so fast

Windows will often turn the monitor off or put the computer to sleep after a short period of inactivity, such as 5 or 15 minutes depending on if it is on battery or not. I like to extend this time so that if I walk away from my computer for a little while, it’s less likely to be asleep when I come back.

To change the power settings:

Use the Start Menu to search for Power settings and open the Power, sleep, and battery settings.
Expand the Screen and sleep section if needed.
Adjust when the computer turns off the screen and goes to sleep to your liking.

Turn on enhanced performance power mode

In that same Power, sleep, and battery settings window, you can adjust the Power mode to prioritize performance over battery life and energy efficiency if you like.

Turn the computer off when I press the power button

By default, Windows will put the computer to sleep when you close the lid, or press the power button. I prefer to have the computer actually shut down when I press the power button. You may want your laptop to do nothing when the lid is closed, so it keeps running.

To change the power button and lid settings:

Use the Start Menu to search for Close lid and open the Change what closing the lid does option.
Adjust the When I close the lid and When I press the power button settings to your liking.
Click Save changes to apply the settings.

Windows features

Show multiple time zones in the taskbar clock

You can configure multiple time zones to show in the taskbar clock when you hover over it or click on it. This is great if you work with people in different time zones, travel frequently, or are a software developer and just want to know what the current UTC time is 😄.

To add additional time zones:

Right-click on the taskbar clock and choose Adjust date/time.
1. You can also search the Start Menu for Date & time settings.
In the Date & time settings window, scroll down and click on the Additional clocks section.
The Date and Time window should open, allowing you to add up to 2 additional clocks and give them friendly names.

The result when hovering the mouse over the clock:

And when clicking on the clock:

Use the Windows Sandbox to test software and settings safely

Windows includes an app called Windows Sandbox. When you open the Windows Sandbox app, it creates a clean virtual environment that looks like a fresh install of Windows. Here you can experiment with software, settings, or files without affecting your main system, and when you close the app everything is erased. This is great for testing software or settings that you’re not sure about, without risking your main system. Just be sure not to save anything important in the Windows Sandbox, as it will be erased when you close it.

The Windows Sandbox app is not installed by default, so you may need to install it from the Windows Features:

Search the Start Menu for Windows Features, and choose Turn Windows features on or off.
In the Windows Features window, scroll down and enable Windows Sandbox.
Click OK to install it.
Restart your computer if prompted.

Now search for Windows Sandbox in the Start Menu to open the app.

Registry tweaks that don’t have a GUI setting

NOTE: Modifying the registry can be dangerous if you don’t know what you’re doing, so be sure to backup your registry before making any manual changes.

You can try the commands below in the Windows Sandbox first to see if you like the changes.

I provide terminal commands instead of manual point-and-click steps for modifying the registry to help ensure that only the intended keys are modified. You can run these commands in PowerShell or Command Prompt.

Some commands shown below may need to be ran from an elevated terminal (e.g. run PowerShell as an Administrator), otherwise you may get an error like Requested registry access is not allowed. Also, you may need to restart your computer for some changes to take effect.

If you are curious about the syntax of the registry commands, you can find the reg.exe MS docs here.

If you want to easily apply all of the registry tweaks below, simply download this .reg file and double-click it to run it.

Disable searching the web in the Start Menu search

When I search from the Start Menu, I want it to only search my local machine.

Here are screenshots before and after disabling the web search:

Run the following command to disable web search in the Start Menu:

reg.exe add "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Search" /v BingSearchEnabled /t REG_DWORD /d 0 /f

To revert back to the default behavior, run:

reg.exe delete "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Search" /v BingSearchEnabled /f

Note that it also disables Copilot, which may or may not be desired.

Always open “More options” context menu in Windows 11+

Windows 11 modified the right-click context menu to only show a few options by default, and you have to click “Show more options” to see the rest. I prefer the previous Windows behavior where all options are shown by default.

Below are screenshots of the context menu before and after running the command.

Default right-click context menu:

Right-click context menu with all options shown:

Run the following command to always show all options in the context menu:

reg.exe add "HKCU\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32" /f /ve

To revert back to the default behavior, run:

reg.exe delete "HKCU\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}" /f

Source and more info

NOTE: Windows 11 updated to allow pressing Shift + Right-click to show all options in the context menu, so you may prefer to do that over using this registry tweak.

Speed up the right-click context menu

When you right-click a file or folder, Windows has an artificial delay of 400 milliseconds before showing the context menu.

Run the following command to change the delay to 50 milliseconds:

reg.exe add "HKCU\Control Panel\Desktop" /v MenuShowDelay /t REG_SZ /d 50 /f

To revert back to the default behavior, run:

reg.exe add "HKCU\Control Panel\Desktop" /v MenuShowDelay /t REG_SZ /d 400 /f

Also, before the context menu is shown, the Send to menu discovers all of the apps and connected devices you can send the file to before it actually shows the menu. We can change this so that it does not enumerate devices until you hover over the Send to menu.

Run the following command to delay Send To from looking for devices right away:

reg.exe add "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer" /v DelaySendToMenuBuild /t REG_DWORD /d 1 /f

To revert back to the default behavior, run:

reg.exe delete "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer" /v DelaySendToMenuBuild /f

Source and more info

Disable delay of startup apps

Windows puts a delay of 10 seconds before it starts launching apps in the Startup folder.

Run the following command to disable the startup apps delay:

reg.exe add "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Serialize" /v Startupdelayinmsec /t REG_DWORD /d 0 /f

To revert back to the default behavior, run:

reg.exe delete "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Serialize" /v Startupdelayinmsec /f

Source and more info

Bonus: Microsoft PowerToys

I was planning to keep this post to only native Windows features and settings, but I couldn’t resist including Microsoft PowerToys. PowerToys is kind of Microsoft’s way of quickly experimenting and iterating on features that should be in Windows, but aren’t. If a feature gets popular enough, it may be included in Windows natively.

Microsoft PowerToys is an application that adds a ton of great features to Windows, and it is being updated all the time.

See the Microsoft PowerToys docs for extensive documentation on all of the features, and how to install and configure them.

A few of my favourite features are:

Always On Top: Keep a window always on top of others.
Find My Mouse: Spotlight the mouse cursor when you press the Ctrl key twice.
File Locksmith: Easily unlock files that are in use by other processes.
Image Resizer: Resize images quickly and easily.
Color Picker: Get the RGB, HEX, and HSL values of any color on the screen.

You can install PowerToys by running the following command in a terminal, such as PowerShell:

winget install --id Microsoft.PowerToys --source winget

Conclusion

I hope you found some of these settings and features helpful. Have a favourite or one that I didn’t mention? Let me know in the comments!

Happy customizing!