The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
A dev center is the platform team’s control plane, holding the catalogs, environment definitions, and network connections; projects map to teams with their own entitlements; and dev box pools within projects pair a definition (image plus compute size, up to serious core counts and memory for the monorepo builders) with a region and network. Developers self serve from the developer portal, create the box, connect over the AVD transport from their laptop, Windows 365 style, and the platform handles the fleet. The governance is the familiar shape: Entra identity and Intune management on every box (they are corporate endpoints, Conditional Access applies, the identity posts’ machinery covers them), auto stop schedules for the FinOps hygiene (a parked dev box bills like the VM it is), and pools in regions near the humans because input latency is the developer experience metric that no feature compensates for.
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
A dev center is the platform team’s control plane, holding the catalogs, environment definitions, and network connections; projects map to teams with their own entitlements; and dev box pools within projects pair a definition (image plus compute size, up to serious core counts and memory for the monorepo builders) with a region and network. Developers self serve from the developer portal, create the box, connect over the AVD transport from their laptop, Windows 365 style, and the platform handles the fleet. The governance is the familiar shape: Entra identity and Intune management on every box (they are corporate endpoints, Conditional Access applies, the identity posts’ machinery covers them), auto stop schedules for the FinOps hygiene (a parked dev box bills like the VM it is), and pools in regions near the humans because input latency is the developer experience metric that no feature compensates for.
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
A dev center is the platform team’s control plane, holding the catalogs, environment definitions, and network connections; projects map to teams with their own entitlements; and dev box pools within projects pair a definition (image plus compute size, up to serious core counts and memory for the monorepo builders) with a region and network. Developers self serve from the developer portal, create the box, connect over the AVD transport from their laptop, Windows 365 style, and the platform handles the fleet. The governance is the familiar shape: Entra identity and Intune management on every box (they are corporate endpoints, Conditional Access applies, the identity posts’ machinery covers them), auto stop schedules for the FinOps hygiene (a parked dev box bills like the VM it is), and pools in regions near the humans because input latency is the developer experience metric that no feature compensates for.
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
A dev center is the platform team’s control plane, holding the catalogs, environment definitions, and network connections; projects map to teams with their own entitlements; and dev box pools within projects pair a definition (image plus compute size, up to serious core counts and memory for the monorepo builders) with a region and network. Developers self serve from the developer portal, create the box, connect over the AVD transport from their laptop, Windows 365 style, and the platform handles the fleet. The governance is the familiar shape: Entra identity and Intune management on every box (they are corporate endpoints, Conditional Access applies, the identity posts’ machinery covers them), auto stop schedules for the FinOps hygiene (a parked dev box bills like the VM it is), and pools in regions near the humans because input latency is the developer experience metric that no feature compensates for.
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
A dev center is the platform team’s control plane, holding the catalogs, environment definitions, and network connections; projects map to teams with their own entitlements; and dev box pools within projects pair a definition (image plus compute size, up to serious core counts and memory for the monorepo builders) with a region and network. Developers self serve from the developer portal, create the box, connect over the AVD transport from their laptop, Windows 365 style, and the platform handles the fleet. The governance is the familiar shape: Entra identity and Intune management on every box (they are corporate endpoints, Conditional Access applies, the identity posts’ machinery covers them), auto stop schedules for the FinOps hygiene (a parked dev box bills like the VM it is), and pools in regions near the humans because input latency is the developer experience metric that no feature compensates for.
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
A dev center is the platform team’s control plane, holding the catalogs, environment definitions, and network connections; projects map to teams with their own entitlements; and dev box pools within projects pair a definition (image plus compute size, up to serious core counts and memory for the monorepo builders) with a region and network. Developers self serve from the developer portal, create the box, connect over the AVD transport from their laptop, Windows 365 style, and the platform handles the fleet. The governance is the familiar shape: Entra identity and Intune management on every box (they are corporate endpoints, Conditional Access applies, the identity posts’ machinery covers them), auto stop schedules for the FinOps hygiene (a parked dev box bills like the VM it is), and pools in regions near the humans because input latency is the developer experience metric that no feature compensates for.
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
A dev center is the platform team’s control plane, holding the catalogs, environment definitions, and network connections; projects map to teams with their own entitlements; and dev box pools within projects pair a definition (image plus compute size, up to serious core counts and memory for the monorepo builders) with a region and network. Developers self serve from the developer portal, create the box, connect over the AVD transport from their laptop, Windows 365 style, and the platform handles the fleet. The governance is the familiar shape: Entra identity and Intune management on every box (they are corporate endpoints, Conditional Access applies, the identity posts’ machinery covers them), auto stop schedules for the FinOps hygiene (a parked dev box bills like the VM it is), and pools in regions near the humans because input latency is the developer experience metric that no feature compensates for.
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Developer onboarding is a number every engineering leader should know: days from laptop receipt to first merged PR. When the answer includes a week of environment setup wiki pages, the fix is treating workstations as a platform product. Microsoft Dev Box is that product, cloud workstations built from your images, governed by your policies, ready in minutes, and distinct from the AVD post’s use cases because these are developer grade machines with a developer lifecycle.
The Structure
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
A dev center is the platform team’s control plane, holding the catalogs, environment definitions, and network connections; projects map to teams with their own entitlements; and dev box pools within projects pair a definition (image plus compute size, up to serious core counts and memory for the monorepo builders) with a region and network. Developers self serve from the developer portal, create the box, connect over the AVD transport from their laptop, Windows 365 style, and the platform handles the fleet. The governance is the familiar shape: Entra identity and Intune management on every box (they are corporate endpoints, Conditional Access applies, the identity posts’ machinery covers them), auto stop schedules for the FinOps hygiene (a parked dev box bills like the VM it is), and pools in regions near the humans because input latency is the developer experience metric that no feature compensates for.
Images and Customization as Code
The image strategy follows the golden image discipline from the VMSS and AVD posts: a base image built by the Image Builder pipeline with the heavyweight common stack (the IDEs, SDKs, container tooling), published through the compute gallery, versioned and rolled forward, never patched by hand. The per team delta rides customizations, YAML task files in the project catalog that install the team specific toolchain, clone the repos, and configure the environment at creation time, which keeps the image count low (the image sprawl trap) while making each team’s box ready to build on first login. Both layers live in Git with the review discipline of everything else in this series, and the payoff compounds: the new joiner’s box materializes in minutes with the code checked out, the security patch lands by image roll instead of a hundred laptop nags, and the it works on my machine class of defects loses its habitat because every machine is the same machine.
Network and the Decisions That Matter
The network connection choice is the architectural fork: Microsoft hosted networking for teams whose work lives in SaaS and public endpoints, or your VNet injection when boxes must reach the private estate, the private endpoints, the internal package feeds, the test databases behind the September networking, in which case the boxes inherit the hub egress, DNS, and inspection like any other workload subnet. Hibernation support preserves the running state through the auto stop cycles, single sign on smooths the entry, and the FinOps model is per box compute plus storage with the stop schedules doing the heavy saving, worth modeling honestly against the laptop refresh budget it partially displaces. The metric to publish quarterly is the one this post opened with, onboarding time to first merged PR, plus the secondary ones (build times on the beefy SKUs versus laptops, security patch latency across the fleet), because Dev Box is a developer experience investment and developer experience investments survive budget season only when measured. The deeper pattern is the series’ recurring one: another undifferentiated burden, workstation setup, converted into a governed, versioned, self service product.
Cheers
Osama
Leave a Reply