Tag: Azure Virtual Desktop

  • How to Update an AVD Golden Image to Windows 11 26H2 Without a Bad Monday

    How to Update an AVD Golden Image to Windows 11 26H2 Without a Bad Monday

    Windows 11 26H2 landed in the Azure Marketplace in September, with multi-session images for Azure Virtual Desktop and new gallery images for Windows 365. Not long after, one admin on Reddit put it on their own machine, opened winver, and found that was the only thing that had changed.

    They weren’t wrong. 26H2 is an enablement package. It shares a codebase and a servicing branch with 24H2 and 25H2, so most of what’s “in” it has been arriving in monthly updates all year. The package flips the switch.

    So don’t look for a feature reason to rebuild your golden image this month. There isn’t much of one. The better reason is in the support dates. This post covers why the move is worth making, why I wouldn’t let a feature update policy make it for you on pooled hosts, and the way I’d actually do it: a validation host pool, a week of real users, and a rollback that’s one click rather than one weekend.

    The real reason to move: the clock, not the features

    Here are the end-of-servicing dates for Enterprise and Enterprise multi-session, straight from Microsoft’s release information page:

    | Version | Build | End of updates (Enterprise / multi-session) | |—|—|—| | 23H2 | 22631 | 10 November 2026 | | 24H2 | 26100 | 12 October 2027 | | 25H2 | 26200 | 10 October 2028 | | 26H2 | 26300 | 9 October 2029 |

    Two rows matter.

    The first is 23H2. If you still have a pooled host pool running a 23H2 multi-session image, you have about five weeks of security updates left. That pool is your priority this month, not the shiny new one. And because 23H2 is on a different codebase, it isn’t an enablement package jump for you; it’s a proper image rebuild.

    The second is 26H2. The image buys you support into October 2029. If you’re on 24H2 today, that’s two extra years on a build you’d be rebuilding at some point anyway. So pick your quietest month. October is fine. A January change freeze is not.

    Why I wouldn’t let a feature update policy do it

    On a physical laptop, letting Windows Update or Windows Autopatch roll out the enablement package is exactly what it’s designed for. On a pooled multi-session host, it’s the wrong tool. Microsoft now says so in writing.

    At the end of August, Microsoft published an AVD page on update methodologies for session hosts. For feature updates on Windows multi-session, Windows Update and Windows Autopatch are both marked Not recommended. Session host update and Azure Compute Gallery images are marked Recommended. In-place upgrades from Setup.exe or an ISO are Not recommended either.

    The reason is drift. A pooled host pool works because every host is the same. The load balancer doesn’t care which host a user lands on, and neither should the user. The moment some hosts take a feature update in place and others don’t (because they were shut down by autoscale overnight, or the install failed on one, or the reboot was deferred), you have two builds in one pool. The user who hits a problem on Tuesday might not hit it on Wednesday. That’s a nightmare to troubleshoot.

    There’s also the next re-image to think about. If the hosts updated themselves to 26H2 but the golden image is still 25H2, the next time you re-image or autoscale builds a fresh host, it comes back on 25H2. You’ve gone backwards. Nobody touched a thing.

    It’s worth checking which policy your session hosts actually sit in. A loosely written dynamic group is all it takes for pooled hosts to land in the same Intune feature update ring as the laptops. This week an r/Intune thread reported Autopatch devices pinned to 25H2 moving to 26H2 anyway. I haven’t reproduced that one, but it’s a good reason to keep pooled hosts out of that ring entirely.

    Step 1: Build the 26H2 image next to the old one, not over it

    The Marketplace SKUs you want are:

    • win11-26h2-avd (offer windows-11): Windows 11 Enterprise multi-session
    • win11-26h2-avd-m365 (offer office-365): the same, with Microsoft 365 Apps

    You can confirm what’s available in your region with:

    az vm image list-skus --publisher MicrosoftWindowsDesktop --offer windows-11 \
    --location uksouth --query "[?contains(name,'26h2')].name" -o tsv

    Build a new image VM from that, then layer your apps and config on exactly as you did for the current image. If you build with a custom image template or a pipeline, this is a parameter change. If you build by hand, I’d use this as the excuse to write the build down, because a rebuild from a fresh Marketplace image is when you find out which settings only ever lived in somebody’s memory.

    Publish it as a new version in Azure Compute Gallery and leave the current version alone. That previous version is your rollback, so don’t let a retention policy delete it the following week. I’d keep at least one known-good version until 26H2 has been in production for a full patch cycle.

    If you run Nerdio Manager, the same idea is built in. Desktop image versions are retained (you set how many to keep), and staging lets you put a new version alongside the active one and test it before you activate it. The current version stays as your backup.

    Step 2: A validation host pool with real users

    A test VM you log into yourself proves the image boots. That’s all it proves.

    I’d recommend a small validation host pool built from the 26H2 image, with the same host pool settings, session limits, RDP properties, and app groups as production. Then put real users in it: five to ten people from different teams, including at least one from whichever team uses the awkward line-of-business app. Give them a week. That’s long enough to catch the things that only happen once a week: the Monday report, the Friday month-end macro.

    If you’d rather not run a separate pool, you can add one or two 26H2 hosts to a production pool in drain mode and steer a test group to them. It works. It’s also the drift problem again, on purpose this time. I’d only do it if the pool is small and you’re watching it closely.

    Step 3: The test checklist

    This is the list I’d work through before anything goes to production. It’s not exhaustive; your own app estate decides the rest.

    • Line-of-business apps. Launch them, and do a real task in each, not just a splash screen. Anything with a licence server or a driver deserves extra attention.
    • Profile attach and sign-in time. Sign in, sign out, sign in again. Compare sign-in times against the current pool. If sign-in has gone from 30 seconds to 90, find out why before the users do.
    • Teams and media optimisation. A call with screen share and video, from the Windows App and from the web client if you support both.
    • Printing and redirection. Printers, scanners, USB devices, clipboard and drive redirection, whatever your RDP properties allow.
    • App attach packages. If you use them, confirm every package still mounts and registers.
    • Security tooling. Defender for Endpoint onboarding, your EDR, and any baseline you apply. Check the host shows up correctly in the portal, not just that the service is running.
    • Policy and layout. Start menu, taskbar, default apps, and anything else set by Intune or Group Policy. Settings occasionally move between releases.
    • The image build itself. If sysprep or the capture failed and needed a retry, write down why. The classic is a Store app that updated in one user’s profile on the image VM.
    • Monitoring and reporting. Any query, workbook, or compliance rule keyed to a build number. 26H2 is build 26300, so a check for 26200 will start flagging your new hosts as out of date.

    To confirm what every host in a pool is actually running, the session host resource reports its OS version:

    az rest --method get \
    --url "https://management.azure.com/subscriptions/$SUB/resourceGroups/$RG/providers/Microsoft.DesktopVirtualization/hostPools/$POOL/sessionHosts?api-version=2024-04-03" \
    --query "value[].{host:name, os:properties.osVersion, status:properties.status}" -o table

    Run it before and after the rollout. You want one build number per pool.

    Step 4: Roll it out with your normal image update

    Once the validation week is clean, I wouldn’t invent a special process for 26H2. Use your monthly image update. Whether that’s session host update, a re-image schedule in Nerdio Manager, or your own pipeline, the whole point is that it’s a process you trust and have run before.

    A few things I’d do differently from a normal month:

    • Go pool by pool. Start with the pool that has the fewest line-of-business apps and the most forgiving users, and finish with the one that keeps you up at night.
    • Roll out midweek. Tuesday or Wednesday gives you working days either side to spot problems. A Friday rollout means the first real users are on Monday morning, which is the bad Monday this post is named after.
    • Remember that image-based servicing replaces the VM. Microsoft’s docs say it plainly: user data and local storage on the session host isn’t kept. On a well-built pooled pool that’s the design, but if anything has quietly started writing to the local disk, you’ll find out now.

    Step 5: Rollback is a version number

    If something breaks after rollout, the fix is to point the host pool back at the previous image version and re-image. That’s it. You don’t uninstall anything, and you don’t hope the rollback option is still there in Settings.

    That’s why Step 1 matters. The rollback only exists if the old version is still in the gallery and you know which version number it is. Write it down in the change record before you start.

    A note for Windows 365

    Windows 365 has three 26H2 gallery images: Windows 11 Enterprise, Windows 11 Enterprise + Microsoft Apps, and the new Developer Configuration + M365 Apps image, which went GA in September. Changing a provisioning policy’s image affects newly provisioned or reprovisioned Cloud PCs, not existing ones, so the same principle applies in a different shape. Test the image on a small group before you switch the policy everybody provisions from. Existing Cloud PCs are single-session and do take feature updates through Windows Update or Autopatch, so the ring question is different there.

    Not exciting, and that’s fine

    The value of 26H2 is two more years of support and nothing much changing for your users, which is exactly what you want from a golden image.

    Three things I’d do this week:

    • Check for 23H2 multi-session first. 10 November 2026 is close.
    • Keep pooled hosts out of feature update rings. Microsoft’s own table marks them Not recommended for multi-session.
    • Build 26H2 as a new image version, give it a week with real users, and keep the old version until you’re sure.

    I’d love to hear how others are timing this one. Are you moving now, or waiting until after the new year?

  • Azure Virtual Desktop Hybrid Is GA. Microsoft Built Half of It on Purpose.

    Azure Virtual Desktop Hybrid Is GA. Microsoft Built Half of It on Purpose.

    I’ve had the same conversation three times this year, with three different customers who all have the same problem. They’re on Citrix, or Horizon, running on hardware they already own (VMware, Nutanix, or Hyper-V), and they don’t want to move to Azure Local. Azure Local means buying a specific validated hardware list from Dell or HPE and running Microsoft’s own hyperconverged stack on top of it. It’s a real product, but it’s a big, separate purchase, and for a lot of these customers, it’s the wrong answer to “get me off Citrix.”

    Azure Virtual Desktop Hybrid went generally available on 1 September 2026, and it’s built for exactly that gap. If you’re running AVD or thinking about running it, and you’ve got hardware you’re not ready to walk away from, this is worth fifteen minutes of your attention. Here’s what it actually is, why Microsoft only built it out to a certain point, and what that means for anyone deploying it without a partner behind them.

    What AVD Hybrid actually is

    Strip away the branding and it’s simple: the AVD control plane (brokering, the web/gateway service, Windows App connections) stays in Azure. The session hosts don’t. You run them on your own hardware, on whichever hypervisor you already have, and register them with Azure using an Azure Arc-enabled agent. Microsoft’s own description is blunt about it: you can run session hosts “on your preferred on-premises hypervisor that supports Windows virtual machines.” No certified hardware list, no proprietary stack to buy. You put the Arc agent on a VM, install the AVD extension, and it shows up in your host pool next to your cloud-hosted hosts.

    That’s the whole pitch, and it’s a genuinely different shape to Azure Local. Azure Local extends Azure’s control plane and management stack into your datacenter on hardware Microsoft has validated. AVD Hybrid does something narrower: it lets your control plane stay entirely in Azure while the compute stays wherever you already have it.

    Users connect the same way they do to any AVD session host: through Windows App, over the same protocol, with the same UI. That consistency is one of the things Microsoft calls out directly, and it’s not a small thing: your helpdesk doesn’t need a second runbook for “if it’s a hybrid session.”

    Why you’d actually use it

    Three scenarios have come up with real customers:

    You’ve got Citrix or Horizon on hardware you’re not ready to sunset. Modernising the broker and connection layer without a forklift migration to cloud compute is a genuinely attractive middle step, especially if that hardware still has years of depreciation left on it.

    Latency-sensitive or data-gravity workloads. CAD, medical imaging, anything where the session traffic needs to stay close to a local dataset. RDP ShortPath still gets you the local-network transport benefit, just without a public cloud hop for the compute.

    Regulated or sovereignty-constrained environments. Some organisations genuinely can’t put certain workloads in public cloud yet, for real regulatory reasons rather than habit. AVD Hybrid lets them get Azure’s management and identity story without moving the data.

    What it doesn’t solve is “we don’t want to touch the cloud at all.” The control plane is Azure, full stop, and your session hosts still need outbound connectivity back to Azure for brokering and management. If the objection is philosophical rather than data-residency-driven, this isn’t the escape hatch.

    The pros and cons, honestly

    Pros:

    • Uses hardware you already own, with no forced capex into a validated Azure Local hardware list
    • Arc-based registration is identity-driven and outbound-only over TCP 443; no inbound firewall holes, no site-to-site VPN required
    • One consistent user experience (Windows App) whether the host is in Azure, on-prem via Hybrid, or a Windows 365 Cloud PC
    • A genuine gradual migration path: move workloads to Azure compute later, on your own schedule, without changing how users connect

    Cons:

    • Windows 11 and Windows 10 Enterprise multi-session isn’t supported on Hybrid. Microsoft’s own licensing table for AVD Hybrid marks it “Not Supported,” full stop. If you want multiple users sharing session hosts on-prem, you’re on Windows Server with an RDS Client Access Licence, which is the same licensing weight Citrix and Horizon customers already carry today. It’s not a cost reduction on that front.
    • You still need reliable connectivity back to Azure. This isn’t an offline mode.
    • And the big one: Microsoft’s own documentation is explicit that AVD Hybrid “doesn’t provision or manage virtual machine state,” which means four things you’d normally take for granted on Azure-hosted AVD simply aren’t there.

    The gap Microsoft left, and why it’s deliberate

    That last point is worth sitting with, because it’s not a bug, it’s the design. Microsoft’s Learn documentation lists exactly what’s missing on a Hybrid host pool: power management, autoscale, Start VM on Connect, and Session Host Configuration. Their own words: “Organizations are responsible for deploying and managing their on-premises session hosts using hypervisor tools, scripts, partner solutions, or other tools.”

    Read that sentence again. Microsoft built the control plane, the Arc registration path, and the identity model, then explicitly handed off VM lifecycle management to whoever owns the hypervisor underneath: you, your scripts, or a partner. That’s not an oversight; it’s the same logic behind Azure Arc generally. Microsoft owns the thin registration and identity layer that has to be consistent everywhere, and leaves the deep, hypervisor-specific automation to the people who already know that hypervisor. Building native Nutanix AHV, VMware, and Hyper-V automation into the AVD product itself would mean maintaining three separate hypervisor integrations inside a first-party Microsoft product. That’s not where their engineering effort is best spent, and building AVD Hybrid this way is what let it ship across any hypervisor at GA rather than one.

    The practical result: without a partner layer on top, running AVD Hybrid at any real scale means someone on your team is scripting VM provisioning, image updates, and capacity management by hand, against whichever hypervisor API you’re on. That’s exactly the operational overhead most of these customers were trying to get away from when they started looking at moving off Citrix in the first place.

    What Nerdio Manager is doing about it

    This is where I have a direct line of sight, because Nerdio was a launch partner on AVD Hybrid alongside Microsoft. Nerdio Manager for Enterprise’s Hybrid support launched with Nutanix AHV as the first supported hypervisor, timed to Microsoft’s GA. What it adds on top of the bare Arc registration: image management (create, update, and deploy gold images for Hybrid session hosts the same way you would for Azure-hosted ones), automation for repeatable provisioning workflows, monitoring across your whole Windows cloud estate (Azure, Azure Local, and now Hybrid) from one console, and cost/utilisation reporting that spans all three.

    Nerdio hasn’t published a public timeline, but VMware and Hyper-V support are the expected next hypervisors after Nutanix, and I’d expect the same direction Nerdio already applies to Azure and Azure Local host pools: bring the automation Microsoft deliberately left out (autoscale, power management, lifecycle orchestration) up to the same standard, regardless of which hypervisor sits underneath. That’s the layer that turns “Microsoft gave you a registration path” into “you can actually run this without a team of scripters.”

    The takeaway

    AVD Hybrid GA is a genuinely useful option if you’ve got on-prem hardware you’re not ready to retire and a real reason (latency, sovereignty, depreciation schedule) to keep compute local while modernising everything around it. Just go in knowing Microsoft built the identity and control-plane layer, and left the VM lifecycle layer as someone else’s job. Check whether that someone is going to be you, with scripts, or a partner, before you commit a migration plan to it.

    If you’re running Citrix or Horizon on hardware you’re not ready to sunset, what’s actually stopping you from testing this? Genuinely curious whether it’s the licensing gap on multi-session, or something else entirely.

  • Nerdio Global Pools: From a Fixed Split to a Deliberate One

    Nerdio Global Pools: From a Fixed Split to a Deliberate One

    If you manage Azure Virtual Desktop at any real scale, you already know the uncomfortable truth about host pools: they don’t know who your users are. A host pool has capacity, a region, and a desktop image. It doesn’t have an opinion about whether the person connecting to it is in Manchester or Mumbai, whether they need the finance app set or the sales one, or whether the pool next door has spare capacity and this one doesn’t.

    For years the answer to “how do I place users properly across a large AVD estate” has been: manually, pool by pool, in a spreadsheet somewhere. Nerdio’s new Global Pools feature, currently in Public Preview for AVD Premium, is the first serious attempt to turn that into policy instead of a project. The preview lays the foundation of an MVP feature that has huge potential for how you manage your host pools.

    The feature you’re probably already running: Host Pool Business Continuity

    Before Global Pools, there’s a feature most Premium customers already have switched on (or should): Host Pool Business Continuity Multi-Region Setup. It’s worth starting here, because it’s the feature Global Pools is quietly built to go beyond.

    It splits new VMs across a primary and secondary Azure region, evenly, and replicates FSLogix profiles between them using Cloud Cache. If a region goes down, users land in the surviving one. It’s a genuinely useful safety net, and it’s available today at host pool level.

    The catch is in that word “evenly.” The split is fixed at 50/50. There’s no weighting, and no way to choose which users go where. A user in Manchester has as much chance of landing in your secondary US region as a user based there already. The feature was built to survive a region failing, and it does that well, but it was never built to place people deliberately. It doesn’t know who the user is, or where they are; it just needs somewhere for them to land.

    That gap is exactly where Global Pools starts.

    What Global Pools actually is

    Nerdio’s own description, from the published KB article: Global Pools let administrators group multiple AVD host pools under shared assignment and failover policies, so users are automatically routed to the right host pool instead of being managed one pool at a time.

    The important architectural point is what it doesn’t touch. Global Pools sits on top of native AVD host pool logic and on top of Nerdio’s own Auto-scale engine. Global Pools is a placement and policy layer, not a new kind of host pool.

    Two things worth knowing before you go looking for it: it’s currently Public Preview, and it’s Premium edition only.

    How it works, in practice

    Strip away the marketing and the mechanics are fairly plain:

    • Assignment is driven by Entra ID group membership. You define policies that route members of specific Entra groups to specific Pool Groups (more on those in a second), with a configurable priority order for anyone who happens to sit in more than one group.
    • Pool Groups bundle one or more host pools together under a shared distribution mode (depth-first or breadth-first), and Nerdio automatically rebalances users across the host pools inside a Pool Group as capacity changes.
    • Sync runs every 15 minutes, automatically, with a manual sync button for when you don’t want to wait.
    • Auto-scale sizing can be percentage-based as well as the traditional fixed host count, useful if you want capacity to track the size of the pool rather than a hard number.
    • Failover policies redirect users from one Pool Group to another for planned maintenance or an outage. In the current release this is a manual cutover: an admin triggers it, it doesn’t happen on its own yet.
    • RemoteApps and the desktop image are defined once per Global Pool, not per Pool Group. The nice touch: you can build the RemoteApp catalogue as a placeholder before any host pool exists in the Global Pool at all. Native AVD doesn’t let you do that.

    None of that requires touching an API, incidentally, because there isn’t one yet. Everything is configured through the Nerdio Manager UI, and you’ll need the Nerdio Admin role to do it.

    Where this is meant to fit

    Nerdio names three scenarios for Global Pools, and they’re a reasonably honest description of who actually needs this:

    1. Large AVD deployments with enough host pools that manual per-pool assignment has stopped scaling.
    2. Failover between Pool Groups during planned maintenance or an outage.
    3. Organisations running multiple identity tenants who want one unified assignment model.

    What it doesn’t do yet

    Nerdio is upfront that this is Public Preview, and the documented gaps back that up:

    • Single-session desktops aren’t supported. If you’re running personal (1:1) host pools, Global Pools isn’t for them yet.
    • No import of existing host pools. Every host pool in a Pool Group has to be created fresh, one at a time, with its workspace and application group deployed manually. If you’re picturing dragging your current 200 host pools into a Global Pool this weekend, that’s not available yet.
    • Assignment is Entra group matching only. No percentage-based or attribute-based assignment, so you can’t yet say “60% of this group goes here, 40% goes there.” (Percentage-based auto-scale sizing is a separate feature and is available; don’t let the two get confused, because it’s an easy mix-up.)
    • Only core host pool profiles are supported inside a Global Pool: Active Directory, VM, and RDP/FSLogix. If your host pool profile relies on something outside that set, it’s not covered yet.
    • No public API yet. Everything is configured by hand in the Nerdio Manager UI.
    • Limited in-UI guardrails. Configuration issues like overlapping failover group membership aren’t flagged for you, so review your policy setup carefully before switching it on.

    None of that is a criticism. It’s a Preview feature, and Nerdio is treating it as one, which is the right call given how much is still moving underneath it.

    What to actually do about it

    If you’re running a handful of host pools, Global Pools probably isn’t solving a problem you have yet. If you’re managing dozens or hundreds across multiple regions, the shape of what Nerdio is building is worth understanding now, even before it’s something you’d put into production.

    Two practical steps:

    First, if you’re not already on it, check Azure Capacity Extender. It’s a separate, established Premium feature that lets you define fallback VM sizes when your preferred size runs out of capacity in a region. I’ve walked more than one customer through exactly that scenario this year, and it costs nothing unless it’s invoked, yet in a lot of estates it’s sitting there switched off. It solves a narrower problem than Global Pools (keeping a host pool running, not placing users across pools) but it’s available today and worth auditing regardless of where you land on Global Pools.

    Second, if you’re running enough host pools that manual assignment has become a real operational cost, get onto the Public Preview and give Nerdio feedback. The honest ask at this stage is “come and tell us what you need it to do,” not “go and build your architecture around this.” Preview features get shaped by the people willing to poke at them early. The gap between “staggered image rollout is listed as a scenario” and “staggered image rollout actually works” is exactly the kind of thing that gets closed faster when real admins are testing against real estates.

    Global Pools is trying to solve a problem that’s been genuinely unsolved in AVD: making user placement a policy decision instead of a spreadsheet. It’s not there yet. But the direction is right, and for anyone running AVD at real scale, it’s worth watching closely rather than waiting for the GA announcement to start paying attention.

    —

    Found this useful? I’d be glad to hear how you’re thinking about host pool placement at scale. Drop a comment, or find me at the next Nerdio event.

  • Context-Based Redirection in Azure Virtual Desktop and Windows 365: A Practical Guide

    Context-Based Redirection in Azure Virtual Desktop and Windows 365: A Practical Guide

    For years, redirection in end-user computing has been a light switch. Clipboard redirection: on or off. Drive redirection: on or off. Printer and USB: same deal. You set it at the host pool or the Cloud PC, and that was the experience for every user, on every device, from everywhere.

    That made sense when “everywhere” meant the office and maybe a corporate laptop at home. It makes a lot less sense now. The same user connects from a managed, compliant laptop in the morning and a personal tablet on the train an hour later. One policy can’t tell the difference, so you end up choosing: lock everything down and annoy people on trusted devices, or open things up and accept the data leakage risk on the ones you don’t control.

    Microsoft’s answer is context-based redirection, now in public preview for Azure Virtual Desktop and Windows 365. This post covers what it is, why it’s worth your attention, and the exact steps to configure it for both platforms, including the gotchas that’ll trip you up if you go in cold.

    What context-based redirection actually changes

    The shift is small to describe and big in practice. Instead of asking “should clipboard redirection be allowed?”, you can now ask “should clipboard redirection be allowed for this session?” — where the session carries context like who the user is, whether their device is compliant, and where they’re connecting from.

    It works by tying a redirection setting to a Microsoft Entra authentication context, which in turn is governed by a Conditional Access policy. The Conditional Access policy is where the actual decision lives: require a compliant device, require a trusted location, whatever your risk appetite calls for. The redirection setting just points at that context and says, “follow those rules.”

    The four redirections you can control this way today are:

    • Clipboard
    • Drive
    • Printer
    • USB

    So a managed, compliant device connecting from a known location can get full clipboard and drive redirection, while the same user on an unmanaged personal device gets neither. Same user, same host pool, different trust, different experience. That’s the whole point.

    Why you’d actually use it

    The honest answer is data leakage control without the usual usability tax.

    Most organisations that care about data exfiltration end up blocking clipboard and drive redirection outright, because the alternative is trusting every endpoint equally. Context-based redirection lets you stop punishing your well-managed estate for the existence of BYOD. Compliant devices get a frictionless experience; everything else gets the locked-down one. You’re matching the control to the actual risk of the session rather than the lowest common denominator.

    It’s the same Zero Trust thinking that’s already shaping authentication, finally applied to device redirection. Less static policy, more dynamic trust.

    Before you start: prerequisites and one big gotcha

    A few things need to be true before any of this works.

    You need Microsoft Entra ID Premium (P1 or P2). Authentication contexts and Conditional Access policies are premium features. If your tenant has no premium licences, the “New authentication context” button is simply greyed out and you’ll go no further. Worth checking first, under Entra ID > Licenses, before you waste twenty minutes.

    It’s still rolling out. This is public preview, and the configuration options are appearing tenant by tenant. If you open your host pool’s RDP properties and don’t see the new dropdown option yet, you’re not doing anything wrong; it just hasn’t reached you. Keep checking back.

    The most restrictive policy wins. This is the one that’ll catch you. If you already manage redirections through other Intune settings or Group Policy, those existing policies can override your context-based configuration, because Windows applies the most restrictive setting. Before testing, set the redirections you want to control to Not configured or Enabled in any existing policies. Otherwise, you’ll configure everything correctly, test it, see nothing change, and lose an afternoon working out why.

    Step 1: Create the authentication context and Conditional Access policy

    This part is identical for both AVD and Windows 365. You’re building the rule that everything else points at.

    1. Sign in to the Azure Portal and search for Microsoft Entra Conditional Access.
    2. Go to Manage > Authentication contexts.
    3. Select New authentication context.
    4. Give it a name and description, something you’ll recognise later, like Compliant devices — full redirection.
    5. Tick Publish to apps and pick a value from the ID dropdown.
    6. Select Save.

    Now, create the Conditional Access policy that gives the context its meaning:

    1. Still in Conditional Access, go to Policies and select New policy.
    2. Name it clearly.
    3. Under Users or agents, include All users (scope this to a pilot group while you test).
    4. Under Target resources, change the dropdown to Authentication context and select the context you just created.
    5. Under Grant, choose Grant access and tick Require device to be marked as compliant, then select.
    6. Set Enable policy to On and select Create.

    That’s the trust decision defined. Compliant device, access granted to the context; non-compliant, denied. Everything downstream now inherits that logic.

    Step 2 (AVD): Map the context in host pool RDP properties

    For Azure Virtual Desktop, the mapping happens at the host pool level, so it applies to every session host in that pool.

    1. In the Azure Portal, search for Azure Virtual Desktop and open it.
    2. Select Host pools and choose your host pool.
    3. Open RDP Properties, then the Device redirection tab.
    4. Find the redirection you want to control — say, Clipboard redirection.
    5. In its dropdown, select Dynamically configure using authentication context.
    6. An Authentication context selector appears. Choose the context from Step 1.
    7. Select Save.

    Repeat for any of the other three redirections you want governed the same way. The Device redirection tab is also where you’ll confirm the preview has reached you: if the dropdown only offers the old static choices (available / isn’t available / not configured), the dynamic option hasn’t rolled out to your tenant yet.

    Step 2 (Windows 365): Map the context in Intune

    For Cloud PCs, the mapping lives in Intune through a Remote Connection Experience policy.

    1. In Intune, go to Devices > Manage Windows 365 Cloud PCs > Cloud PC Settings.
    2. Select Create > Remote Connection Experience (preview).
    3. Give it a name and description.
    4. Under Configuration settings > Device redirections, find your target redirection and select Authentication context: Context-based redirection.
    5. Choose your authentication context in the selector that appears.
    6. Set any scope tags, then move to Assignments.

    This is the second gotcha worth burning into memory: assign the Remote Connection Experience policy to device groups (your Cloud PCs), not user groups. Context-based redirection for Windows 365 is enforced at the device level. Assign it to users, and it simply won’t apply. Finish with Review + create.

    Step 3: Validate it works

    Testing needs two devices at different trust levels, which is the only honest way to prove it’s working.

    1. Connect from a managed, compliant device that satisfies your Conditional Access policy. Confirm the configured redirections are available in the session.
    2. Connect to the same host pool or Cloud PC from a BYOD or non-compliant device. Confirm the redirections are restricted or gone.

    If the behaviour isn’t what you expect, work through this list before assuming the feature is broken:

    • Check the Conditional Access policy assignment and the authentication context configuration.
    • Check the device’s compliance status in Microsoft Entra ID / Intune.
    • Check the host pool RDP property (AVD) or the Remote Connection Experience policy assignment (Windows 365).
    • Check for any existing redirection policy that might be overriding it — remember, most restrictive wins.

    That last point is, nine times out of ten, the culprit.

    Where this fits

    Context-based redirection won’t change your architecture, but it does close a gap that’s been awkward for a long time: the gap between “trust this endpoint completely” and “trust it not at all.” Most real estates live somewhere in the middle, and until now, the tooling didn’t.

    It’s preview, so treat it as preview — pilot it, don’t roll it across production on day one, and keep an eye on the docs as the configuration surfaces light up across tenants. But it’s the kind of incremental, sensible control that’s genuinely useful the moment it lands. If you run Azure Virtual Desktop or Windows 365 and you’ve ever had the BYOD-versus-data-leakage argument, this is one to test.

    Found this useful? I’d be interested to hear how you’re approaching device trust in your own EUC estate — drop a comment.

  • AVD-Assess: a free, open-source Well-Architected health check for Azure Virtual Desktop

    AVD-Assess: a free, open-source Well-Architected health check for Azure Virtual Desktop

    The Well-Architected Framework for Azure Virtual Desktop is genuinely good documentation. Five pillars, dozens of concrete recommendations, all the right guidance on scaling plans, FSLogix redundancy, Trusted Launch, Private Link, and the rest. If you run AVD at any scale, you’ve probably read it at least once.

    So why do so many AVD estates still drift away from it?

    The problem was never the guidance. It’s that turning a framework into an actual answer for your environment has, until now, meant one of three things: pay for a commercial assessment tool, sit through a manual review where someone clicks around the portal for a day, or (let’s be honest) do nothing and hope the next outage isn’t the one the framework warned you about.

    I got tired of that gap, so I built something to close it. This post is what it is, the problem it solves, and how it works under the bonnet.

    The problem, stated plainly

    A framework is a checklist you have to apply yourself. The WAF for AVD tells you that pooled host pools should have a scaling plan, that multi-session hosts want Premium SSD, that public network access on a host pool is rarely necessary in an enterprise with site-to-site connectivity. All true. All useful.

    But “apply this 80-page framework to a five-subscription estate, by hand, every quarter” is not a realistic ask for a team that already has a day job. The guidance is free; the act of operationalising it isn’t. That’s the bit that was missing: a free, automated way to take the framework and produce an answer you can act on and hand to a sponsor.

    What AVD-Assess actually is

    AVD-Assess is a single PowerShell script. You point it at a subscription, it connects, reads your AVD environment, runs 25 best-practice checks across all five WAF pillars (Cost, Reliability, Security, Operational Excellence, and Performance Efficiency), then writes a self-contained HTML report with traffic-light scoring and specific remediation for every finding.

    No agent. No install beyond the Az modules you almost certainly already have. Nothing leaves your tenant. It’s MIT-licensed and lives on GitHub. A run takes about five minutes.

    The part I care about most is that every finding is specific. Not “consider reviewing your scaling plans”. Instead:

    0 of 5 pooled host pool(s) have a scaling plan. Uncovered: Ar-TEST1, CS-Multisession, QKEntra, RF-EntraIDOnly, RF-MultiSession.

    followed by exactly what to do about it and a link to the relevant Microsoft Learn article. A finding you can’t act on isn’t a finding. It’s a feeling.

    How it works

    The flow is deliberately boring, because boring is reliable:

    # One-time: install the modules
    Install-Module Az.Accounts, Az.DesktopVirtualization, Az.Compute, Az.Monitor, `
    Az.Resources, Az.Network, Az.Storage, Az.Security -Scope CurrentUser
    git clone https://github.com/waynebellows/AVD-Assess.git
    cd AVD-Assess
    ./AVD-Assess.ps1 -OpenReport

    It signs you in, or reuses your existing context with -UseExistingConnection, which is handy in Azure Cloud Shell where you’re already authenticated. It then collects everything up front: host pools, session hosts, VMs, NICs, disks, diagnostic settings, Defender pricing, private endpoints. Every check reads from that one snapshot rather than making its own calls, so a run is consistent and doesn’t hammer the API.

    Permissions are intentionally modest. Reader on the subscription covers the bulk of it. Two checks want a little more scope (Defender for Cloud coverage and Service Health alerts), and if they don’t have it, they degrade to an informational result rather than failing the run. A tool that needs Owner to tell you about your scaling plans is a tool nobody runs.

    The scoring model

    Each check returns a status and a score from 0 to 100:

    • Pass (green): meets best practice.
    • Warning (amber): a partial gap.
    • Fail (red): a real cost, reliability, or security risk.
    • Info (teal): couldn’t be evaluated, or doesn’t apply to this environment.

    Category scores are the average of the scored checks; the overall score is the average of the categories. The design decision I’m most pleased with is how Info is handled: it’s excluded from the averages entirely. If a VM fetch failed on a permissions boundary, the affected checks go Info, and the report says 4 of 6 scored next to the donut instead of quietly pretending a green ring is the whole story. A score that flatters you is worse than no score.

    What it checks, across the five pillars

    A flavour rather than the full list:

    • Cost: scaling plan coverage on pooled pools, Start VM on Connect, unhealthy hosts still accepting sessions, max session limits.
    • Reliability: session host health, RDP Shortpath, agent update rings, availability-zone spread, FSLogix profile redundancy.
    • Security: drive and clipboard redirection, Trusted Launch and Secure Boot, Entra ID join status, Defender for Cloud coverage, AVD Private Link.
    • Operational Excellence: diagnostic settings flowing to Log Analytics, resource tagging, Service Health alerts, load-balancing algorithm.
    • Performance Efficiency: Accelerated Networking, Premium OS disks on multi-session hosts, Gen2 VMs, FSLogix region colocation.

    Every one names the affected resources and links to the official documentation, so the report is the start of the fix, not just a verdict.

    From a snapshot to a trend

    A one-off score tells you where you are. It doesn’t tell you whether you’re getting better, and “is this improving?” is the question a sponsor actually asks. Running the London Marathon taught me that a single training run means very little; the line through all of them means everything. The same is true of an estate’s health.

    So the latest version turns AVD-Assess from a snapshot into a tracking tool. It can emit a structured, versioned JSON document alongside the HTML, ready to feed into a dashboard or a pipeline gate. Point it at a previous JSON report and every score, down to the individual check, gets a movement badge: improved, regressed, or unchanged. New checks are flagged; checks no longer assessed are listed separately so nothing silently disappears between runs.

    # Baseline today
    ./AVD-Assess.ps1 -UseExistingConnection -OutputFormat Both -OutputPath .\avd.html
    # Next month, see what moved
    ./AVD-Assess.ps1 -UseExistingConnection -OutputFormat Both -CompareTo .\avd.json

    Real estates also span more than one subscription: production, development, disaster recovery. There’s a sweep mode that assesses every subscription your identity can see in a single pass, writes a report per subscription, and produces a roll-up landing page. A subscription you can’t read is skipped with a reason rather than aborting the whole run, because one inaccessible subscription shouldn’t cost you the other four.

    Why it’s free and open source

    Because the framework is free, and the tooling to apply it should be too. There’s also a selfish reason: open source means the checks get scrutinised, and scrutinised checks are trustworthy checks. If you disagree with how a threshold is scored, you can read exactly how it’s calculated and tell me I’m wrong. That’s the point.

    It’s not a replacement for knowing your environment. It won’t catch everything, and a green score is not a certificate of perfection. It’s the absence of the specific problems it knows how to look for. Treat it as a fast, honest first pass that frees you up to think about the things a script can’t.

    Where to start

    Clone it, run it against a development subscription first, and look at your lowest-scoring pillar. Pick one finding. Fix it. Run it again next month and watch that arrow go green. That loop (measure, fix one thing, then measure again) is worth more than any single report.

    It’s on GitHub here: https://github.com/waynebellows/AVD-Assess

    If you run it and something’s wrong, or a check should score differently, open an issue. I’d genuinely rather hear it.

  • Your Most Locked-Down Users Just Got AVD’s Biggest Connectivity Upgrade in Years

    Your Most Locked-Down Users Just Got AVD’s Biggest Connectivity Upgrade in Years

    You know the user. They’re in financial services, healthcare, or government. Their network team blocks UDP at the firewall because it’s harder to inspect than TCP, and the risk appetite is zero. They’ve heard you talk about RDP Shortpath and how it transforms the AVD experience — lower latency, better audio, fluid video, no session drops. And then they remind you, politely, that none of that applies to them.

    Because their UDP is blocked. Has been for years. Probably always will be.

    For these users, Azure Virtual Desktop has always meant one thing for connectivity: a single TCP tunnel punched through port 443 to Microsoft’s Azure Gateway infrastructure, via a mechanism called Reverse Connect. No shortcuts, no direct paths, no Shortpath. Just TCP — and if that one path hiccups, the session degrades or drops.

    Microsoft just changed that. And it’s bigger than the announcement makes it sound.


    First, a Quick Primer on How AVD Connectivity Actually Works

    Before unpacking what’s new, it’s worth being precise about the layers involved — because the terminology gets muddled.

    AVD has two fundamental transport modes:

    RDP Shortpath (UDP): A direct or relayed UDP connection between the Windows App client and the session host. This uses STUN (Simple Traversal Underneath NAT) for direct peer-to-peer discovery, or TURN (Traversal Using Relays around NAT) when a relay is needed. UDP is faster, has lower latency, and handles packet loss more gracefully than TCP for interactive desktop traffic. This is what most people mean when they say “optimised AVD connectivity.”

    Reverse Connect (TCP): When UDP is unavailable — blocked firewall, restrictive proxy, NAT that won’t play ball — AVD falls back to a TCP connection routed through Microsoft’s Gateway infrastructure on port 443. Every hop goes through Azure’s control plane. It works, but it’s a longer path, more sensitive to latency, and historically, it’s been a single connection with no redundancy.

    RDP Multipath — introduced in public preview last year — added intelligence on top of this. Rather than just connecting on one path and hoping for the best, Multipath continuously evaluates multiple network routes simultaneously and keeps backup paths warm on standby. If the active path degrades, it silently switches to the next best option — no reconnection required, no session drop, often imperceptible to the user.

    The original Multipath implementation focused on UDP paths. Multiple STUN routes, multiple TURN relays, intelligent failover between them. For organisations running RDP Shortpath over UDP, it was a genuine step forward in session resilience.

    But for TCP-only environments? Nothing changed. You still had one TCP tunnel, and Multipath’s safety nets didn’t extend to you.

    Until now.


    What Redundant TCP Multipath Actually Does

    Microsoft this week announced public preview of redundant TCP transport paths for RDP Multipath. The headline is short, but the implication is significant.

    Here’s what it means in practice:

    For environments where UDP is available, Multipath now maintains redundant UDP paths and standby TCP paths simultaneously. UDP remains the preferred and primary transport — it’s faster, and if it’s working, you want it. But when UDP paths degrade or fail, the system now has TCP paths pre-established and ready to take over instantly, rather than scrambling to establish a new connection under duress.

    For environments where UDP is blocked entirely — the financial services firms, the government agencies, the healthcare organisations — this is the more significant change. These environments have historically relied on a single active TCP Reverse Connect path. Now, Azure Virtual Desktop can establish multiple standby TCP paths in parallel. If the active TCP tunnel becomes degraded or fails, the system automatically switches to the next available TCP path without requiring a reconnect.

    Think about what that means operationally. A transient ISP hiccup, a brief VPN instability, a brief network path interruption — these used to manifest as a session freeze followed by a reconnect dialogue. With redundant TCP paths, the session moves silently to the next available path. The user might not notice anything at all.


    Why This Matters More Than It Seems

    The AVD connectivity story has always had an implicit two-tier problem.

    Tier one: organisations that can open UDP ports and run RDP Shortpath. These users get low-latency, high-quality sessions with increasingly sophisticated resilience features. Microsoft has invested heavily here.

    Tier two: organisations where network policy, compliance requirements, or legacy infrastructure means UDP isn’t an option. These users have always had a degraded experience by comparison — not because AVD couldn’t deliver quality, but because the transport architecture underneath it left them with fewer options.

    Multipath’s original launch improved tier one significantly. Redundant TCP Multipath is the first meaningful improvement for tier two. And tier two is disproportionately large in the enterprise segments where AVD is growing fastest — regulated industries where network teams run tight ships.

    This also matters for a subtler reason. Even in environments where UDP is available, there are scenarios where redundant TCP paths matter: a mobile device roaming between networks, a user on a hotel Wi-Fi that quietly blocks UDP, a VPN split-tunnelling configuration that misbehaves. Having TCP redundancy as a backstop makes the entire connectivity architecture more robust, not just for the edge cases.


    The Technical Reality of “Silent Failover”

    It’s worth being specific about what “automatic switching” means here, because it’s not magic.

    RDP Multipath uses ICE (Interactive Connectivity Establishment) — the same protocol that video conferencing platforms have been using for years to negotiate optimal network paths between peers. ICE discovers and ranks available routes, keeps them evaluated continuously, and triggers a path switch when the active route falls below the threshold.

    For TCP paths specifically, Multipath uses a mechanism called Rendezvous to establish Reverse Connect paths. Multiple Rendezvous connections are established to different relay endpoints, maintained on standby, and promoted to active status if the primary path fails. The session state is preserved throughout — the switch happens at the transport layer, not the application layer, so the desktop session itself continues uninterrupted.

    This is the same basic architecture that makes modern video conferencing resilient. Teams, Zoom, and WebRTC-based applications have solved this problem. It’s taken longer for RDP — a protocol with very different characteristics — to get there. But it’s getting there.


    How to Enable It and What You Need

    This is currently in public preview, and there are two requirements:

    Host pool side: You need to opt your host pool into the Validation ring. The feature is enabled by default for host pools in validation, with no additional configuration required.

    Client side: Users must be running Windows App version 2.0.1069.0 or later on a Windows device. This is important — the classic Remote Desktop client doesn’t support this. Other platforms (macOS, iOS, Android) aren’t currently supported either. If your user population is Windows-heavy, you’re well-positioned. If you have significant macOS or Linux client usage, you’ll need to wait.

    To verify Multipath is active, users can check the connection bar in their remote session — it will indicate RDP Multipath is enabled. Administrators can validate connectivity patterns in Azure Virtual Desktop Insights under the connection reliability use case.

    If you want to test without the validation ring, you can also enable Multipath manually via registry on individual session hosts:

    reg add "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\RdpCloudStackSettings" /v SmilesV3ActivationThreshold /t REG_DWORD /d 100 /f

    Users need to disconnect and reconnect after the registry change takes effect.


    The Bottom Line

    Redundant TCP Multipath isn’t going to transform your AVD environment overnight, and it doesn’t close the gap between TCP and UDP performance — UDP is still faster, and you should still strive to enable Shortpath where network policy allows.

    But it quietly solves a problem that has affected some of the most demanding enterprise AVD environments for years: the fragility of single-path TCP connectivity in restrictive networks.

    If you have customers or users in finance, healthcare, government, or any sector where the network team is conservative, and UDP isn’t on the table — put this on your radar, opt a test host pool into validation, and start building the evidence for a change.

    The users who’ve always had the worst AVD connectivity experience are finally getting some of the resilience that everyone else has had for a while. That’s worth paying attention to.


    More on AVD connectivity architecture at modern-euc.com. Follow me on LinkedIn for weekly EUC insights.

    References:

  • Habit #7: Optimise Log Analytics

    Habit #7: Optimise Log Analytics

    Visibility is essential — but it shouldn’t come at any cost.

    Monitoring is a critical part of running Azure Virtual Desktop.

    Without it, you’re blind to performance issues, login delays, and user experience problems.

    But there’s a trade-off that many teams don’t fully realise:

    Observability isn’t free.

    And in many environments, Log Analytics quietly becomes one of the largest — and least optimised — costs in Azure.

    That’s where Habit #7 comes in.

    Highly effective admins don’t just enable monitoring.
    They optimise it.


    The Hidden Cost of Visibility

    Log Analytics is incredibly powerful.

    It provides deep visibility into:

    • Session performance
    • User experience
    • Host health
    • Application behaviour

    But it works by ingesting data.

    And in Azure, you don’t pay for storing most of that data (at least initially).
    You pay for ingesting it.

    That means:

    The more frequently you collect data, the more you pay.

    In many AVD environments, default configurations collect data far more frequently than needed for day-to-day operations.

    The result?

    High ingestion volumes… and unexpectedly high costs.


    What Log Analytics Optimisation Really Means

    Optimising Log Analytics isn’t about turning monitoring off.

    It’s about collecting the right data, at the right frequency, for the right purpose.

    In Nerdio Manager for Enterprise, admins have control over how telemetry is collected and retained.

    This includes:

    • Data collection frequency (polling intervals)
    • Performance counters being captured
    • Retention periods

    The goal isn’t to reduce visibility.

    It’s to remove unnecessary noise.


    The Three Pillars of Habit #7

    Like every habit in this series, this comes down to consistent, repeatable behaviour.


    Pillar 1: Review What You’re Collecting

    Most environments collect far more data than they actually use.

    Highly effective admins regularly review:

    • Which performance counters are enabled
    • Whether those metrics are actively used
    • Which dashboards or reports depend on them

    A simple question helps guide this:

    “If we stopped collecting this data, would anyone notice?”

    If the answer is no, it’s likely unnecessary.


    Pillar 2: Adjust Collection Frequency

    One of the biggest cost drivers in Log Analytics is how frequently data is collected.

    By default, many metrics are captured every 30 seconds.

    For most environments, that level of granularity isn’t required.

    Adjusting polling intervals to:

    • 60 seconds
    • 120 seconds
    • Or even longer for certain metrics

    …can significantly reduce ingestion volume without materially impacting visibility.

    The data is still there.

    It’s just collected more efficiently.

    Log Analytics Optimisation in Nerdio Manager.

    Pillar 3: Align Retention with Real Needs

    Not all data needs to be kept forever.

    Highly effective admins:

    • Align retention periods with operational requirements
    • Keep short-term data for troubleshooting
    • Retain longer-term data only where it adds value

    For many teams, a 30-day retention window is more than sufficient for operational analysis.

    Anything beyond that should be intentional.


    What This Habit Enables

    When Log Analytics is optimised properly:

    • Monitoring costs drop significantly
    • Data ingestion becomes predictable
    • Dashboards remain effective
    • Troubleshooting capability is preserved

    Most importantly:

    You maintain visibility — without overpaying for it.


    Common Mistakes to Avoid

    Log Analytics optimisation is often overlooked or misunderstood.

    Some common pitfalls include:

    • Leaving default collection settings unchanged
    • Collecting high-frequency data that’s never used
    • Retaining data longer than necessary
    • Reducing data collection too aggressively without understanding impact

    The goal is balance.

    Too much data increases cost.
    Too little data reduces visibility.


    How Habit #7 Builds on the Previous Habits

    By this stage, the environment should already be well optimised:

    • Images are standardised
    • Patching is predictable
    • Applications are decoupled
    • Autoscale is tuned
    • VM sizing is aligned with demand

    Habit #7 completes the picture.

    It ensures that the monitoring layer itself is optimised, not just the infrastructure it observes.


    The Real Takeaway

    Monitoring is essential.

    But more data doesn’t always mean more value.

    Highly effective admins understand this.

    They don’t collect everything.

    They collect what matters.

    And they do it efficiently.


    Closing the Series

    That’s the final habit in the series.

    The 7 Habits of Highly Effective Nerdio Admins aren’t about individual features.

    They’re about operational discipline:

    • Build consistently
    • Patch predictably
    • Separate concerns
    • Optimise continuously
    • Use data to drive decisions

    Individually, each habit adds value.

    Together, they create environments that are:

    • Stable
    • Scalable
    • Cost-efficient
    • Predictable

    And ultimately — easier to manage.

  • Habit #6: Regularly Right-Size Using Nerdio Advisor

    Habit #6: Regularly Right-Size Using Nerdio Advisor

    The environment you designed six months ago probably isn’t the environment you’re running today.

    Most Azure Virtual Desktop environments start out well-designed.

    VM sizes are carefully chosen.
    Host pool capacity is planned.
    Autoscale is configured.

    At the beginning, everything fits.

    But environments rarely stay static.

    Users come and go.
    Applications change.
    Workloads evolve.

    Over time, what was once the right size often becomes the wrong size.

    That’s why Habit #6 exists.

    Highly effective admins don’t assume their original VM sizing decisions are still correct.

    They validate them regularly.


    Environment Drift Is Inevitable

    Even the most disciplined environments drift.

    Over time, you may see:

    • Increased user density on session hosts
    • New applications changing resource demands
    • Departments adopting new workflows
    • Seasonal fluctuations in usage

    None of this means that something was configured incorrectly.

    It simply means the environment evolved.

    The risk comes when sizing decisions stay frozen while everything else changes.

    That’s where right-sizing becomes essential.


    What Right-Sizing Actually Means

    Right-sizing isn’t about aggressively shrinking VM sizes.

    It’s about aligning infrastructure with real demand.

    In Nerdio Manager for Enterprise, Nerdio Advisor helps surface opportunities where VM sizes or host counts no longer match usage patterns.

    It analyses:

    • CPU utilisation trends
    • Memory utilisation
    • Host density
    • Historical workload behaviour

    From this data, it can highlight potential opportunities to:

    • Reduce VM size
    • Adjust host counts
    • Improve session density
    • Eliminate unused capacity

    Advisor doesn’t force changes.

    It simply shows where optimisation may exist.


    The Three Pillars of Habit #6

    Like the other habits in this series, right-sizing becomes effective when it’s treated as a repeatable behaviour rather than a one-time task.


    Pillar 1: Review Advisor Recommendations Regularly

    Right-sizing should be part of your operational rhythm.

    Highly effective admins review Advisor recommendations periodically to understand how their environment is evolving.

    These reviews help answer questions such as:

    Are hosts consistently underutilised?
    Are machines running close to resource limits?
    Has user demand changed since the environment was first deployed?

    Looking at these trends regularly prevents small inefficiencies from turning into long-term overspend.


    Pillar 2: Validate Host Pool Sizing Against Real Demand

    Advisor recommendations are a starting point.

    Before making changes, administrators should validate recommendations against how the environment is actually used.

    Important considerations include:

    • Login storms
    • Peak usage periods
    • Critical applications
    • Future growth expectations

    Right-sizing should always balance efficiency with user experience.

    The goal is optimisation — not risk.


    Pillar 3: Make Incremental Adjustments

    The most successful optimisation strategies are gradual.

    Highly effective admins:

    • Test smaller VM sizes in validation pools
    • Adjust session density carefully
    • Monitor performance after changes
    • Iterate based on real results

    This approach ensures improvements are sustainable and predictable.

    Large, aggressive changes introduce uncertainty.

    Small, measured adjustments build confidence.


    What This Habit Enables

    When environments are regularly right-sized, several things happen.

    First, infrastructure becomes more efficient.

    Unused capacity is eliminated, and VM sizes better match the workloads they support.

    Second, costs become more predictable.

    Right-sizing ensures organisations are paying for what they actually use — not what they once needed.

    Finally, operational confidence improves.

    Administrators know their environment reflects current demand rather than historical assumptions.


    Common Mistakes to Avoid

    Right-sizing is powerful, but it can be misunderstood.

    Some common pitfalls include:

    • Treating right-sizing as a one-time exercise
    • Blindly applying recommendations without validation
    • Optimising based on short-term usage spikes
    • Reducing VM sizes too aggressively

    Good optimisation is disciplined.

    It balances cost efficiency with stability.


    How Habit #6 Builds on the Previous Habits

    By the time organisations reach Habit #6, the earlier habits have already created a stable foundation.

    Images are standardised.
    Patching is predictable.
    Applications are decoupled from images.
    Autoscale behaviour is understood.

    Only once that foundation exists does right-sizing become safe.

    Without it, changing VM sizes can introduce instability.

    With it, right-sizing becomes one of the most powerful cost optimisation tools available.


    The Real Takeaway

    Infrastructure decisions age.

    What worked six months ago may not be optimal today.

    Highly effective admins recognise this.

    They don’t rely on past assumptions.

    They validate them.

    Regular right-sizing ensures that the environment you’re running today reflects the demands of today — not the design decisions of yesterday.

    That’s the essence of Habit #6.


    Next in the series:
    Habit #7 — Optimise Log Analytics

    Monitoring is essential for maintaining visibility into your environment, but unmanaged telemetry can quietly inflate Azure costs. The final habit explores how to maintain observability while keeping analytics costs under control.

  • Habit #5: Analyse Auto-Scale History

    Habit #5: Analyse Auto-Scale History

    Insights show what might be wrong. History tells you why.

    Auto-scale is designed to react to demand.

    Users log in → hosts scale out.
    Users log off → hosts scale in.

    Simple in theory.

    But in the real world, Auto-Scale behaviour can sometimes look confusing:

    • Hosts scale out earlier than expected
    • Machines stay online when no users remain
    • Capacity spikes suddenly
    • Scaling appears inconsistent

    When this happens, many admins immediately start tweaking auto-Scale settings.

    The most effective admins do something different first.

    They look at the history.


    Auto-Scale Behaviour Often Tells a Story

    When Auto-Scale behaves in ways that seem unexpected, it’s rarely a bug.

    More often, it’s Auto-Scale doing exactly what it was configured to do — just reacting to signals you might not have noticed.

    Auto-Scale makes decisions based on inputs such as:

    • Active user sessions
    • CPU utilisation
    • Memory utilisation
    • Session limits
    • Time-based schedules

    If any of these signals change, Auto-Scale responds.

    Without reviewing historical behaviour, those responses can feel random.

    But once you analyse the history, patterns start to emerge.


    What Auto-Scale History Reveals

    Auto-Scale History in Nerdio Manager for Enterprise provides a timeline of scaling behaviour so you can understand exactly what happened.

    It allows administrators to see:

    • When scale-out events occurred
    • When hosts scaled back in
    • What triggered each scaling decision
    • How host capacity changed throughout the day

    Instead of guessing why Auto-Scale reacted, you can see the reasoning behind every action.

    This turns Auto-Scale from a black box into an explainable system.


    The Three Pillars of Habit #5

    Highly effective admins don’t just glance at Auto-Scale history when something goes wrong.

    They analyse it regularly.

    Three behaviours make this habit effective.


    Pillar 1: Correlate Scale Events with User Activity

    Auto-Scale should follow user demand.

    That means scale-out events should align closely with increases in user sessions.

    By reviewing Auto-Scale history alongside session activity, you can identify patterns such as:

    • Morning login storms
    • Midday workload peaks
    • Shift-based usage patterns
    • End-of-day session drop-offs

    When scaling events align with user behaviour, your Auto-Scale configuration is doing its job.

    If scaling happens too early or too late, it may indicate that thresholds or session limits need adjustment.

    The key is understanding how demand drives capacity.


    Pillar 2: Analyse Resource Utilisation Trends

    User sessions alone don’t tell the whole story.

    Resource utilisation often reveals why Auto-Scale behaves the way it does.

    Review historical trends for:

    • CPU utilisation
    • Memory utilisation
    • Average sessions per host

    These metrics help answer important questions:

    Are hosts consistently underutilised?
    Are machines running near capacity?
    Are session limits too conservative?

    In many environments, utilisation data quickly reveals opportunities to right-size VM families or adjust session density.

    Without this context, Auto-Scale decisions can appear unpredictable.

    With it, they become completely logical.


    Pillar 3: Identify Inefficient Scaling Patterns

    Auto-Scale history also helps reveal inefficiencies that quietly increase costs.

    Examples include:

    • Hosts running overnight with no active sessions
    • Scale-out events creating more hosts than needed
    • Frequent scale-in and scale-out oscillations
    • Burst hosts being created unnecessarily

    One-off events rarely matter.

    Patterns do.

    When these patterns appear repeatedly, they often indicate that scaling thresholds or schedules can be refined.

    Small adjustments can eliminate significant waste over time.


    What This Habit Enables

    When administrators regularly analyse Auto-Scale history, scaling becomes predictable.

    Instead of reacting to unexpected behaviour, teams gain:

    • Clear visibility into scaling decisions
    • Faster troubleshooting when anomalies occur
    • Evidence-based optimisation
    • Improved cost control
    • Greater confidence in Auto-Scale configuration

    Auto-Scale stops feeling mysterious.

    It becomes something you understand and control.


    Common Mistakes to Avoid

    Even experienced teams can misinterpret Auto-Scale behaviour.

    Some common pitfalls include:

    • Reviewing only one day of historical data
    • Optimising around short-term anomalies
    • Ignoring weekly or seasonal usage patterns
    • Adjusting Auto-Scale settings without understanding triggers

    Auto-Scale optimisation works best when decisions are based on consistent trends rather than isolated events.

    Looking at several weeks of history often reveals the true behaviour of an environment.


    How Habit #5 Builds on Habit #4

    Habit #4 focused on Auto-Scale Insights.

    Insights help surface potential optimisation opportunities — such as idle capacity or oversized VM SKUs.

    Habit #5 goes one step further.

    It explains why those opportunities exist.

    When you combine insights with historical analysis, you create a powerful feedback loop:

    Insights highlight optimisation opportunities.
    History explains the behaviour behind them.

    Together, they allow admins to refine Auto-Scale configurations with confidence.


    The Operational Discipline Behind Great Environments

    The most stable Azure Virtual Desktop (AVD) environments don’t rely on trial and error.

    They rely on observation.

    Highly effective teams treat Auto-Scale history as part of their operational routine.

    They review it:

    • During monthly environment reviews
    • When investigating performance issues
    • After major application or user changes
    • When evaluating cost optimisation opportunities

    Over time, this creates a deeper understanding of how the environment behaves.

    And that understanding leads to better decisions.


    The Real Takeaway

    Auto-Scale isn’t magic.

    It’s simply a system responding to signals.

    When those signals are understood, scaling becomes predictable.

    And predictable systems are easier to optimise.

    That’s the real value of Habit #5.


    Next in the series:
    Habit #6 — Regularly Right-Size Using Nerdio Advisor

    Even well-designed environments drift over time. The most effective admins continuously validate that their VM sizing still reflects real demand.

  • Habit #4: Act on Auto-Scale Insights

    Habit #4: Act on Auto-Scale Insights

    Don’t set it and forget it.

    Auto-scale is one of the most powerful features in Azure Virtual Desktop.

    It promises elasticity.
    It promises cost control.
    It promises performance stability.

    But here’s the reality:

    Most environments drift.

    Auto-scale gets configured once — often during deployment — and then quietly left alone. Months later, usage patterns have changed, user numbers have shifted, and application behaviour has evolved… but scaling logic hasn’t.

    That’s where Habit #4 comes in.

    Highly effective Nerdio admins don’t treat auto-scale as a static configuration.
    They treat it as a feedback loop.


    Auto-Scale Drift Is Normal

    Even well-designed environments don’t stay optimal forever.

    Over time:

    • Users join or leave
    • Working hours shift
    • Seasonal spikes come and go
    • Applications change resource profiles

    None of this means the original configuration was wrong.

    It just means the environment evolved.

    The problem isn’t drift.
    The problem is ignoring it.


    What Auto-Scale Insights Actually Do

    Auto-Scale Insights in Nerdio Manager for Enterprise surface where your configuration no longer reflects reality.

    They highlight:

    • Idle capacity
    • Inefficient scaling schedules
    • Burst logic that may be too conservative — or too aggressive

    Insights don’t make changes for you.
    They show you where opportunity exists.

    They turn instinct into evidence.


    The Three Pillars of Habit #4

    Like the other habits, this one breaks down into repeatable behaviours.

    You don’t need a dramatic reconfiguration.
    You need a disciplined review.


    Pillar 1: Review Insights Regularly

    Auto-scale should have an operational cadence.

    Highly effective admins:

    • Review Insights monthly (or at minimum quarterly)
    • Look for trends, not one-off anomalies
    • Treat it like a performance and cost dashboard

    Small adjustments made regularly compound over time.

    What’s dangerous isn’t one imperfect configuration.
    It’s leaving it untouched for a year.


    Pillar 2: Validate Provisioning Against Real Usage

    The question isn’t “Is autoscale enabled?”

    The question is:

    Does our current provisioning reflect how the environment is actually being used?

    Review:

    • Active and disconnected sessions per host
    • Scale-out frequency
    • Ramp, peak, and taper events
    • Host counts during low-demand periods

    As a general rule of thumb, sustained utilisation below ~60% often signals overprovisioning. Sustained utilisation above ~80% may indicate constrained performance.

    The goal isn’t to chase perfect numbers.

    The goal is alignment between capacity and demand.


    Pillar 3: Optimise Safely, Not Aggressively

    Cost optimisation should be invisible to users.

    Highly effective admins:

    • Adjust VM size incrementally
    • Modify session limits gradually
    • Tune burst thresholds cautiously
    • Validate performance after changes

    Aggressive optimisation introduces risk.

    Disciplined optimisation builds confidence.


    What This Enables

    When Auto-Scale Insights are acted on consistently:

    • Compute costs drop meaningfully
    • Scaling becomes predictable
    • Surprise overruns decrease
    • Performance stabilises

    More importantly, optimisation becomes a data exercise — not guesswork.

    This aligns strongly with my broader emphasis on disciplined, data-driven decision making.


    Common Mistakes to Avoid

    Even experienced teams fall into these traps:

    • Blindly applying every recommendation without context
    • Optimising based on one week of data
    • Ignoring seasonal workload patterns
    • Tuning autoscale before stabilising images and applications

    Order matters.

    Autoscale optimisation works best when:

    • Images are consistent
    • Patching is predictable
    • Applications are disciplined

    That foundation makes scaling behaviour easier to interpret — and safer to adjust.


    How Habit #4 Builds on the Foundation

    Habit #4 doesn’t stand alone.

    It builds on:

    • Habit #1: Standardised image management
    • Habit #2: Predictable patching
    • Habit #3: Controlled application delivery

    Only when the environment is stable does autoscale optimisation become safe.

    Otherwise, you’re just scaling instability faster.


    The Real Takeaway

    Autoscale isn’t about turning machines on and off.

    It’s about continuously aligning capacity with reality.

    Set it.
    Measure it.
    Refine it.

    That’s the habit.


    Next up: Habit #5 — Analyse Auto-Scale History
    Insights show what might be wrong. History tells you why.