Back to Blog
Foqal

Run Ops. Not Just Requests

Stay updated

Product

  • AI Agents
  • Request Management
  • Workflow Automations
  • Integrations

Solutions

  • All Solutions
  • IT Help Desk
  • IT Operations
  • HR & People Ops
  • Customer Support

Resources

  • Blog
  • Events
  • Customers
  • Feature Roadmap
  • Status
  • Support

Company

  • About
  • Brand
  • Contact
  • Security
  • Privacy
  • Terms

2026 Foqal, Inc. All rights reserved.

XLinkedIn
ITSecurityConceptsService Desk9 min read

When IT stops issuing commands and starts declaring desired state

Vlad Shlosberg
Vlad Shlosberg
Founder

A content-caching declaration I pushed last spring did absolutely nothing for eleven minutes.

I checked the scope. The device was online, had checked in nine minutes earlier, and reported healthy. I pushed it again. Still nothing. No error on the device, no error in my management console, and no ticket, because from the user's point of view nothing had happened, and nothing happening is not something people file tickets about.

The answer was sitting in the device's status channel the whole time. My configuration needed at least one of allowed sharing or personal caching turned on, and I had left both unchecked. A clear validation error, correct behavior, reported in the one place I hadn't thought to look.

I resisted declarative management for two years, which I justified as caution and was mostly laziness. I've come around. But the thing I had wrong was never whether to adopt it. It was what adopting it does to the shape of your failures.

Twenty years of the same idea, wearing new clothes

The earliest Mac OS X releases had no management layer to speak of. You wrote defaults write commands against preference domains and hoped. Then came directory-based management, Workgroup Manager and Open Directory, where settings were scoped to a computer or a user and cached locally. Starting with Lion, native MDM configuration profiles: XML .mobileconfig payloads pushed from a server, installed on the device, still scoped, still cached. Then declarative device management, introduced in 2021.

If you have to explain this to a security committee or a nervous director, lead with that lineage. Architecturally this is the same pattern Apple has shipped for two decades: scoped settings, cached locally, still in effect when the device is offline. What changed is the serialization. JSON declarations over a sync protocol instead of XML profiles over a command channel. Even the vocabulary mostly survived, with device and user "channels" playing the role "computer and user" played in the Workgroup Manager era.

What genuinely changed is who decides when.

Classic MDM is a server giving an order and then asking whether the order was carried out. Declarative hands the device a description of desired state and lets it act on its own schedule, including re-applying a setting that somebody reverted, without waiting to be told a second time.

And then there's the part where you don't get a choice. The original OS-update scheduling commands are slated for removal in the next major release. More pressing: as of a recent version, you can no longer push software-update settings through classic MDM commands at all. Declarative is the only path. The old software-update binary technically still exists and is unreliable enough that nobody sensible builds on it.

So this is not a "someday, when we have bandwidth" migration. It has a date attached, and the date belongs to somebody else, which is roughly the entire argument for starting now.

Anatomy, in about ninety seconds

Every declaration carries three fields: a type, a unique identifier (usually a UUID), and a server token, which is a revision marker so the client knows which version is authoritative.

There are four categories, and the distinctions matter more than they look.

Configurations are the settings payload: passcode policy, removable storage restriction, software update enforcement. Roughly the analog of a profile payload.

Assets are references to external data a configuration needs: certificates, large installer files, disk images, fetched from a URL. That URL can point at your MDM server. Apple explicitly recommends that it doesn't, and suggests a CDN or object store instead, because asset delivery has to survive an entire fleet pulling on it at the same moment. The dusty Intel Mac mini in the closet that also runs MySQL is not a candidate.

Activations are a set of configurations plus their referenced assets, and they apply automatically only when every referenced piece is valid.

Management declarations are static metadata about the management relationship, largely just who manages this device.

Sit with the word "only" in that third one. If a dependency is missing, or the device fails a stated predicate such as a minimum OS version, the activation does not apply. No error surfaced to the end user. Nothing on screen, nothing in the notification tray.

Silent non-application is the defining characteristic of declarative systems. It's the feature and the bug, in the same behavior.

Content image

The takeover trick is genuinely elegant

Here's the mechanism that made me stop rolling my eyes.

A "legacy profile" declaration wraps an existing .mobileconfig inside a declaration, either via a hosted URL or the newer asset reference. The device then performs a management takeover of the already-installed profile, in place, without removing and reinstalling it. The identifier and UUID of the declaration have to match the existing profile exactly, and the payload count has to match one to one. Once takeover succeeds, later MDM install, update, or remove commands against that identifier simply fail, by design, because the profile now belongs to the declarative side.

Users see zero prompts. No re-approval, no reconnection, no "your administrator has changed settings" dialog. Some environments run the takeover overnight during Power Nap and there is no visible impact whatsoever the next morning.

Then there's the bug.

Once an environment wraps more than roughly 10 to 15 profiles into legacy-profile declarations for a single device, the legacy-profile subsystem locks up and does not recover on its own. The device needs a manual reboot before it will accept any further declarations, and the recovery command that used to kick the subsystem back into life stopped working as of a recent minor release. Nobody found this in documentation, because there is no documented limit. It surfaced through internal dogfooding at a team that had already migrated around 300 profiles, and it was still reproducible on the newest beta at last test.

The place this hurts is new-device enrollment. A laptop that needs a manual reboot five minutes after the user unboxes it is a support conversation you will be having, personally, with somebody's VP.

I don't think this should stop you from migrating. I think it should stop you from migrating everything in one weekend, which is a different sentence.

What you can still see afterwards, and what you can't. Legacy profiles are inspectable. You can open System Settings, look at Profiles, or run system_profiler against the profile data type and get a reasonable picture of what's installed.

Asset-backed declarative configurations mostly are not independently auditable by third-party tools. Outside your own MDM vendor's status-channel data, there's currently no reliable way to inspect what a DDM asset actually contains once it lands. Apple's own guidance amounts to "read them out from your MDM server," which assumes, without ever saying so, that your MDM tracked what it pushed and can still tell you. Some can. Some cannot, and you find that out during an evidence request.

There's also an unresolved design question. If a declaration references an asset at a URL, and the content at that URL changes without the URL changing, it is genuinely unclear what the device does. Safe practice is to version the URL on every update rather than mutate content behind a stable one. Five seconds now, or a three-day investigation later.

The stampede

Declarative software updates work beautifully and will take down your network.

Push a single update declaration to a thousand-machine site with 500 devices online, and every one of them starts pulling the same multi-gigabyte payload from the vendor CDN at the same instant. One admin described the sequence as their phone lighting up, followed by the network team demanding to know who took down the site. The MDM vendors describe fleet staggering as outside their scope. The platform vendor describes it as the MDM vendor's job. You, holding a saturated branch-office link, get to sort it out.

The mitigations that work in production right now are unglamorous. Content caching, where one site's host served 37GB to clients in a 24-hour window with only 4GB pulled fresh from upstream. Sharding the declarations across batches or subnets, which you have to ask your vendor for. Scheduling for off-peak local hours, meaning 3am in the region rather than 3am at headquarters.

Silent failure is the whole category

Once you start looking for it, this pattern is everywhere in modern endpoint management, not only in declarations.

New app blocking through the endpoint security framework gives the user no feedback at all. A blocked app bounces once in the Dock and stops. No dialog, no explanation. That's a ticket titled "my Mac is broken," and the person filing it is being entirely accurate.

Plugins that lose a dependency after an OS upgrade don't throw errors either. A virtual camera plugin just produces no video feed. A content-caching host got physically pulled from a rack by another team during hardware cleanup and sat missing for two weeks with nobody noticing, because clients fall back to pulling from Apple and end users experience nothing worse than a slower download.

The best answer I've seen to this comes from a Mac admin who applies the declarative philosophy by hand, with property lists written directly onto managed machines. One of them stores the expected computer name. A daily check compares the actual name against the stored one and reverts unauthorized renames without ever asking the user why they did it. That's desired state, implemented in about nine lines of shell.

The same admin got taught the harder lesson. A single long-running compliance check began failing after a routine OS update and restart, with no error anywhere. A couple dozen machines simultaneously lost their SSO profile, fell out of compliance, and stopped reporting compliance data upstream, which meant the system designed to notice problems was itself the problem and couldn't say so. Their fix was to add a second, much simpler, much dumber check running alongside the first, so that one fragile detector is no longer a single point of failure for a compliance-critical chain. No cleverness involved anywhere in it.

I've since stolen that pattern for things that have nothing to do with device management. Two checks that fail for different reasons beat one clever check every time.

There's a related idea from teams running their MDM configuration as code in Git. Their pipelines do full reconciliation on every run instead of incremental diffing: fetch everything currently deployed, walk every file in the repo, create what's missing, update what differs, mark orphans for deletion. It costs extra API calls and buys correctness that doesn't depend on pipeline history. A missed run gets caught by the next one. Same philosophy, different layer, and it's the closest thing to a guarantee you'll get.

Before you wrap a single profile

  1. Subscribe to the status channel and route it somewhere a human looks daily. A channel in Slack or Teams beats a dashboard nobody opens.
  2. Keep wrapped legacy profiles per device well under 10 until the lockup is fixed. Where a native declaration type exists, migrate to it rather than wrapping.
  3. Ask your MDM vendor four questions: do you support management takeover, does wrapping use the URL method or the asset method, do you handle identifier matching, and what's your OS-version cutoff plan.
  4. Version every asset URL. Never mutate content behind a stable one.
  5. Add a second, dumber check for anything that gates compliance or access.
  6. Before an update declaration touches more than a few hundred devices, know exactly where the bytes will come from and at what local hour.
  7. Keep your own record of what you pushed, on a system that isn't the thing doing the pushing.

The part that isn't technical

Every step in this twenty-year progression traded direct control for reliability. defaults write did exactly what you told it and nothing more. Profiles held their settings even when the server was unreachable. Declarations go further and let the device repair itself without asking permission. Each of those trades was correct, and each one moved the failure a little further from your eyes.

Loud failures are expensive and honest. They interrupt you, they generate tickets, and they force a fix. Silent ones are cheap right up until the day an auditor, or a new hire holding a locked-up laptop, presents the bill for six months of accumulated interest.

Declarative management is a bet that the device knows better than the server when to act. It's a good bet. The cost is that the device stops telling you when it decides not to.

Adopt it. Just don't adopt it alone.


Foqal puts IT status, alerts, and requests in the chat tools your team already has open, so the things your fleet stops saying out loud still reach a human.

Subscribe to our newsletter

Get the latest insights on IT operations, AI, and workplace productivity delivered to your inbox.

Ready to transform your support?

See how Foqal can help your team deliver faster, smarter support.

Start Free Trial

Related Articles

IT

Change control for IT teams that don't have a change board

A small IT team can turn chaotic, untracked scripts into a reliable, auditable system by moving to Git‑backed version control, protected branches, and automated CI pipelines that sync and safely delete changes. This approach eliminates guesswork, adds security, and ensures every edit is traceable.

IT Help Desk

What your IT team wishes you knew about submitting a support ticket

Why category ambiguity, self-diagnosis and missing screenshots slow every help desk down, with a copy-paste request template. Plus the reciprocal list of what IT needs to stop doing.

IT

AI in the IT helpdesk: what's actually working in 2026, and what isn't

An honest split between the AI IT support tasks that genuinely work now (classification, log triage, knowledge base answers) and the ones that fail badly, with the failure data and real incidents.