M365Con 2027 – free online conference · 11–22 Jan 2027 · 120 sessions m365con.net

2026-11-19

Host Pools and Session Hosts – Simply Explained

Follow the showNew episodes on Microsoft 365, Copilot and more, free in your podcast app.Apple PodcastsSpotify
Cover: Host Pools and Session Hosts – Simply Explained
Host pool and session host: two Azure Virtual Desktop terms that sound like the same thing and are not. One of them hides a decision you cannot easily undo, and it shapes both your Azure bill and your users' experience. In this episode of Simply Explained you will learn: - What a host pool really…

Show notes

Host pool and session host: two Azure Virtual Desktop terms that sound like the same thing and are not. One of them hides a decision you cannot easily undo, and it shapes both your Azure bill and your users' experience. In this episode of Simply Explained you will learn:

  • What a host pool really is, and why the settings live there
  • What a session host is and how user sessions behave on it
  • Personal vs pooled host pools, and the one choice that is hard to undo
  • How users get routed to a machine, including breadth-first, depth-first and drain mode
  • Why images and templates matter, and how autoscale keeps the Azure bill down
  • The common mistakes, and when one host pool is not enough

Simply Explained by M365.FM breaks down Microsoft 365, Azure and modern IT topics in clear, jargon-free language. Hosted by Mirko Peters. Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-microsoft-365-azure-cloud-power-platform-ai--6704921/support. This episode includes AI-generated content.

Host: Mirko Peters

Guests

Guests in this episode:

Transcript

Transcript (TXT)

Read the full transcript

Speaker 1: Two words, host pool and session host, are where a lot of people get stuck in Azure Virtual Desktop. They sound like they describe the same thing, and that's exactly where the confusion starts. One of them holds a decision you can't easily take back, and it changes what you pay and what your users get. We'll untangle both terms in plain words with examples and the honest limits. No jargon, no deep Azure knowledge, just 20 minutes to get them straight. A host pool is a container. It groups a set of Azure virtual machines together. and publishes desktops or applications to a set of users. That's the whole idea and everything else follows from it. The part that matters is where the settings live. A host pool holds the choices that apply to every machine inside it. The way sessions get balanced, the most sessions a single machine should carry, and the schedule that controls which machines are switched on all get set at the pool level. Change one of those and every machine in the pool picks up the change. Take a mid-sized company with two kinds of users, The accounting team needs a full Windows desktop with their finance software installed. The call center team only ever uses two browser-based tools. Those are two different host pools because they need different things published to them. That word published is worth a sentence. When you publish something in this world, you're deciding what shows up for the user after they sign in. It might be a complete desktop or it might be two applications sitting side by side. A host pool is also where an application group comes in An application group decides what the pool offers, either a full desktop or a set of individual applications. A desktop group works with pooled or personal pools, while a group of individual applications only works with pooled ones. Every application group also has to belong to a workspace, and the workspace is what the user sees when they sign in. So a host pool is the container that holds your settings, decides what gets published, and gives the service a group of machines to work with. A pool gives you one image and one set of rules to manage. Now let's look at the second term. A session host is an actual virtual machine, a real computer running in Azure, and it's the machine a user's desktop session runs on. The pool is the group, and the session host is the machine doing the work inside it. When we say a session host is registered to a pool, we mean the machine has been joined to it so the service knows it's there and available to take sessions. That handshake is what makes it usable. Users never connect to the pool directly and they never see it because the pool is like an address and the session host is the house at that address. The service uses the pool to work out where to send someone and the machine is where they land. Once a user is on a machine, their session can be in one of a few states. An active session means they're signed in and connected right now, while a disconnected session means they close the window without signing out. That sounds like it ends the session and it doesn't, When they reconnect, they go back to the exact same session, on the exact same machine, with everything still open where they left it. A third state, called pending, is a placeholder. It holds a spot on a machine while the sign-in finishes, because signing in can take anywhere from 30 seconds to 5 minutes, depending on the user's profile. Without that placeholder, someone else's sign-in could finish first and take the seat. You've probably lived through all of this without knowing the names. Closing the lid on a laptop and opening it later to find your work exactly where you left it is a disconnected session coming back to life. Every host pool is one of two types and this is the choice I hinted at earlier because a pool is either personal or pooled. One gives each user their own machine and the other shares machines between users. A personal host pool is a one-to-one arrangement. Each user gets a machine that belongs to them, and the maximum session limit is one because one person uses it. Users either get assigned directly to a specific machine, or they're placed on the first available one and stay there. Every time they sign in, they land on the machine they were assigned to. A pooled host pool is a many-to-one arrangement. Several users share a single machine at the same time, each inside their own isolated session. Nobody is tied to a particular machine, so if a user signs out and signs back in later, They might land somewhere else entirely. That's by design, and it's what keeps costs down. The trade-off is easy to say. Personal costs more per user and gives that user a consistent, dedicated machine. It suits developers, power users, and anyone running something heavy like graphics work or a GPU workload. Pool costs less per user because the machines are shared, and it suits task workers, call centers, and people running standardized web applications. There's more to it than price, though. In a personal pool, a user always uses the same machine so their profile can live right there on that machine's disk. In a pooled pool, users move around so their profile has to live somewhere separate from the machine. That's why pooled setups usually pair with a profile solution that follows the user rather than the machine. Updates follow the same split. A personal machine is updated in place the way you'd update any computer with Windows Update or a management tool. Pool machine is usually replaced rather than patched because it's easier to build a fresh one from a new image than to update a machine that several people are using. This is the detail that catches people out and it's the reason I opened with it. The host pool type is set when you create the pool and you can't change it later. If you build a pool pool and decide you need it personal, you're not flipping a setting because you're building a new pool and moving users across to it. That's why it's worth deciding this one on paper before you touch anything, and the way a shared pool sends people to machines has rules of its own, which is exactly where we're going next. So the pool is built, and it's a pooled one. A user opens the Windows app client and clicks their desktop. The interesting part is what happens between that click and the desktop appearing. The service takes over at that point, working out which host pool that user belongs to, finding a machine in that pool with room and sending the connection there. That routing piece is often called the broker and the user never sees it. From their side, they clicked an icon and a desktop opened. If the pool is personal, this part is simple because the user goes to their own machine every time. If the pool is pooled, the service has to choose between two methods. One is called breadth-first and it spreads sessions across the machines to keep things even. The other is called depth first and it fills one machine up to its limit before it moves to the next. The two methods point in different directions. Breadth first favors performance because the load is spread out, while depth first favors cost because it packs people onto fewer machines and lets the rest stay switched off. Breadth first isn't perfectly even and that surprises people. It picks at random from roughly the half of machines with the fewest sessions So the spread ends up close but not exact. That's deliberate and it's fine in practice. Depth first has a requirement that trips people up. It needs a maximum session limit to work with. If you leave that limit at its default, the service will keep filling a machine past the point where it should stop and you get worse performance without the cost saving you were chasing. Microsoft's default for a new pool is effectively unlimited so that's a setting you have to touch on purpose. One more behavior is worth knowing and it's called drain mode. A machine in drain mode stops taking new connections but keeps serving the people already on it, so nobody gets kicked off. And if a user had a disconnected session on a machine that's now draining, they reconnect to that same machine rather than being sent elsewhere. A drain mode is how you retire a machine politely instead of pulling it out from under someone. Put it together and the picture is clear. A personal pool sends people to a machine they already own, while a pooled pool makes the service choose. And that choice is where your performance and your bill start to diverge. Every machine in a pool should come from the same image so that everyone gets the same experience. When machines in one pool drift apart, users start reporting problems that only happen on some machines, and those are the hardest problems to solve. Image management has three layers, and it helps to keep them straight. At the top is the golden image, the master copy that holds the operating system, the company-wide applications, and the security settings. Below that is a template machine for one specific pool, which starts from the golden image and adds that pool's size, its department applications, and its policies. At the bottom are the session hosts themselves, the machine's users connect to, all cloned from that pool's template. One rule saves the most time here, so make your changes on the template rather than on individual machines. Why that matters is what happens to a session host in a pooled pool, and the short answer is that those machines are disposable They get deleted and rebuilt during scaling operations and image updates, so anything you change directly on one of them disappears the next time it's replaced. You install a printer driver on a machine, it works, and a week later the machine is gone and the driver with it. If a change needs to survive, it belongs on the template. The update itself follows five steps in a fixed order, and each one depends on the last. You power on the template and make your changes, installing software and applying updates. Next, you generalize the image, which strips out machine-specific details so it can be cloned cleanly. Then you set the updated template as the new image for the pool, and you replace the existing session hosts with new machines built from it. It's five steps rather than one, because the image has to be generalized and the machines have to be swapped rather than patched in place. Nothing skips the swap in a pooled pool, the honest cost of doing this by hand is worth naming. Nerdio reports third-party testing that found updating a custom image through the Azure portal takes about 146 clicks and re-imaging session hosts takes about 90. Those figures come from the vendor rather than an independent study, so treat them as a sense of scale rather than a precise measurement. In so, the shape of the problem is real and it multiplies by every pool you run and every update cycle you go through. One genuine upside is that testing an image change is safe. Spin up a single session host, apply the change and check it. If it breaks, delete that machine and clone a fresh one from the current template so you lose a test machine rather than a production pool. That is how image updates stay predictable instead of becoming a weekly surprise. The money side of this comes down to one fact and it's easy to remember. A virtual machine that is switched off and deallocated stops billing for compute. Everything else is secondary to that. Autoscale is the service that decides which machines are running and when. and it works from a scaling plan. A plan has four phases across the day. Ramp up covers the start of the day when usage picks up, and peak covers the busiest hours. Ramp down covers the evening when people start leaving, and off peak covers the quiet stretch when almost nobody is on. The mechanics are more intuitive than they sound. Auto scale watches how full the pool is, measured as a percentage of the capacity you've set, and when that number climbs above a threshold you choose, it switches on another machine. When usage drops, it switches the machine off, but only if doing that won't push the pool back over the threshold. That second condition is why scaling doesn't get jumpy. There are two versions of this. Power management autoscaling switches machines on and off, and it's generally available. The newer one, which Microsoft calls dynamic autoscaling, can also create and delete machines, but it's still in preview, It only works with pooled pools that use a session host configuration, and it isn't available in Azure Government. A couple of things to note before you plan anything. A pool can only have one scaling plan, although you can point one plan at several pools of the same type. A plan runs in a single time zone, and AutoScale can't share a pool with the older Azure Automation scaling script, so you pick one and commit to it. AutoScale also overrides some pool settings while it's running, For pooled pools, it applies load balancing from the schedule rather than from the pool's own setting, and it overwrites drain mode. That's why Microsoft recommends tagging machines you're updating with an exclusion tag. A machine with a matching tag is left alone, which keeps Autoscale from switching it on or off while you work. One more idea changes how fast a session feels, and it's called a standby machine. A standby machine is provisioned but switched off. When someone connects and nothing running as room, The standby machine boots instead of a new one being built from scratch, which turns a wait of several minutes into a wait of seconds. You pay nothing for it while it sits there switched off. Two things keep autoscale from being a magic cost button. It won't sign people out unless you turn on force sign-off during ramp down, so it can only consolidate machines that are already empty. And it can only save what your schedule really matches, so a schedule that doesn't reflect real usage saves less than you'd hope. The settings you choose here are also where the quiet mistakes live. A short list of mistakes shows up again and again in these environments, and none of them are exotic. They are the ordinary ones that come from doing the obvious thing. One mistake shows up more than any other, and it's the tempting one, which is editing a session host directly. On a pool pool, those machines get rebuilt, so the change is temporary whether you meant it to be or not. Put the change on the template instead. Another common one is leaving the maximum session limit at its default. The machines then run fuller than they should and performance drops without the saving you were after. Set that number to match what a machine can handle. Permissions trip people up too. Nerdio's guide flags assigning the scaling permissions at the resource group level instead of the subscription level as a common misconfiguration. The result isn't a clear warning. Scaling just doesn't work the way you expect and you go looking in the wrong place. Then there's the quiet one. where autoscale and another scaling script are running on the same pool, they fight each other, and the behavior you see is whatever won the last round, only one of them should be running. The expensive mistake is choosing the wrong pool type and only realizing it months later when the type can't be changed. That's not a fix, it's a migration. Then there are the honest limits, the things that aren't mistakes so much as conditions. A few of the newer capabilities are still in preview, so their behavior can change under you. Managed identity is now required in more places and Nerdio's guide reports that since September 2025, new pools created through the Azure portal must use it and that as of November 2025, existing pools using a session host configuration can't create new session hosts without it. If you're running older tooling, that's a project rather than a checkbox. One more limit is worth stating plainly. The maximum session limit is a target, not a wall. When a lot of people connect in the same instant, The number of sessions on a machine can briefly go over your limit. It's not a bug and it's not a sign that your setting didn't apply. Those are the traps that live inside a single pool. Once you're running more than one, they start to multiply. A small setup usually starts with one host pool and that's a fine place to start. Larger environments often end up with several and the reasons are practical rather than technical. Different users need different machines and that's the most common reason to split. A call center agent working in a browser doesn't need the same machine as an analyst running a spreadsheet model with half a million rows. Put them in one pool and you're forced into a bad choice, which is to hold back the analyst or overspend on the agent. Time zones cause splits too. A scaling plan runs in one time zone and that has a real consequence. If you have people in New York and Los Angeles, a schedule that scales down at 6 in the evening Eastern time is cutting capacity while the West Coast is still working. Separate pools per region, each with its own schedule, fix that without leaving people stranded. Images and applications push the same way. A pool is tied to one image, so when a department needs its own software, that usually means a separate pool to go with it. None of this comes free. More pools means more templates, more images, and more schedules to keep in step. Every extra pool is another place where configuration can drift. And drift is how two environments that were supposed to be identical quietly stop being identical. That's the honest trade-off. You split pools to solve a problem and you take on more to keep track of in return. So the short version looks like this. A host pool is the container and the settings, and a session host is the machine doing the work. Personal means one machine per user, and pooled means shared machines. The pool type is the one choice that's hard to undo, so make it on purpose. If you take one thing away, take this, get the pool type and the image right before you scale anything, and set the maximum session limit deliberately instead of leaving it at the default. Here's my question for you. In your environment, which one causes more trouble, the image updates or the scaling schedule? If this made the topic feel less intimidating, subscribe to M365FM to master the tools and the mindset shaping the future of work.