The Line That Never Widened
Copyright© 2026 by Alexander Winston
Chapter 15: The Application That Knew Where It Belonged
April 2001 through February 2002
Janet Lewis signed into an available workstation at the branch with her ordinary identity, the way she’d done a hundred times before whenever the main office sent her out to cover a short-staffed morning. Her network rights followed her. Her GroupWise mailbox followed her, address and calendar and all. The banking application did not.
The client on this machine was a version behind the one she used at headquarters, and the one on the workstation beside it was older still, having missed a manual update that a technician had never been able to apply because the workstation stayed in active use through every scheduled visit, with no window free to take it down. Janet knew the job cold. Her identity was correct. The workstation was authorized, sitting right where it belonged in the branch’s own inventory. The software on it was simply wrong, and the older client presented her fields in an unfamiliar order and left out a validation check the bank now quietly depended on to catch a certain kind of teller error before it became a real one.
Curtis had marked the discrepancy the only way he currently trusted — small colored dots stuck to the workstation cases and copied onto a printed floor plan taped inside a supply closet, a system that existed nowhere except in his own memory and his own handwriting. He showed Ellen the new report ManageWise had generated the week before: several hundred workstations, three confirmed application versions, and a fourth category that simply read version not confirmed. The report had found the problem cleanly. It couldn’t touch it. Application assignment and the actual state of a workstation belonged to a different product entirely, one ManageWise had no authority to reach into.
Ellen read the report twice before she asked the question that was going to occupy the rest of the year. “The directory already knows who Janet is. The bank already knows which application she needs to do her job. So why,” she said, “is Curtis still walking around with a bag of colored dots?”
Curtis didn’t take the question personally, though he might have been forgiven for it. He’d kept that floor plan current for three years, and it had never once been wrong about what he’d actually gone and checked with his own hands. What it couldn’t do was scale past the size of his own memory, and everyone in the room, including him, had known that for at least as long as it had been working.
Sarah brought Front Range’s report to Ruth Calder expecting, by now, exactly the reception she got.
Ruth’s team didn’t receive it as an assignment. They set it down beside a compatibility matrix that already ran to a dozen pages, inventory reports going back over a year, workstation-agent builds already in their third or fourth revision, application-package tests still running in a lab two buildings over, and a UnixWare port that had started the moment the shared interfaces underneath it had gotten stable enough to be worth targeting. “This is a good customer case,” Ruth said, without any edge to it. “It isn’t the reason we started. We started because the common platform finally gave us something worth building the next version on top of.”
She laid out the departmental boundary the same unhurried way Diane and Marcus and Lillian each had before her. ZENworks had its own approved budget and its own roadmap, set well before Front Range’s version drift had ever reached anyone’s desk. Sarah and Eric owned the shared UnixWare, eDirectory, and certification commitments the product depended on; Ruth owned the product itself, and the decision about what it actually did.
What she didn’t own, and said so before anyone assumed otherwise, was the assumption buried in the sentence “make Janet’s applications follow Janet.” It sounded complete. It wasn’t. Some assignments belonged with a person. Others belonged with a machine, a department, a branch, or a whole class of hardware, and no single rule could honestly cover all four at once. The system had to know not only who Janet was, but what kind of machine she’d just sat down at, and what work that particular location was actually permitted to do.
Ruth sketched three boxes on the whiteboard rather than trying to explain it in one sentence. USER held Janet herself — her groups, her role, her rights. WORKSTATION held the machine — its operating system, its memory and disk space, its location, its own registered identity independent of whoever happened to be sitting at it. APPLICATION held the software itself — the approved package, its version and dependencies, its licensing rule, the conditions under which it was allowed to install at all. A policy engine connected the three boxes to each other. It never collapsed them into one.
Sarah recognized the shape of the argument before Ruth had finished drawing it, though she kept that to herself for the moment. It was the same discipline the directory itself had needed years earlier — separate the identity from the thing it was allowed to touch, and never let a shortcut blur the two together just because, on any given morning, they usually lined up.
The architecture review ran on Front Range’s own applications rather than invented examples, because Ruth had learned that an abstract category always sounded cleaner than the actual mess a bank produced.
The GroupWise client could follow an authorized user to whatever suitable workstation she reached, since ZENworks only ever distributed the client itself — Diane’s own product kept every bit of authority over the mailbox and the server underneath it, exactly as it always had. The teller application was different by design: it belonged to registered teller stations or teller-station groups, and it had no business appearing on an executive’s laptop merely because a teller had signed into it once to help someone out. Loan-analysis software split the difference — assigned through a user or a job-role group, but only when the workstation actually met the required operating system, memory, and display conditions, and only when the assignment itself fell within the bank’s own approved seat count for that license. ZENworks could enforce the assignments the bank had approved and report faithfully on what was actually installed against them; whether a given seat was legally available in the first place was the bank’s own policy to set and the vendor’s own agreement to define, not a determination ZENworks could make on its own authority. Antivirus definitions, Novell Client updates, and the occasional Windows service fix belonged to the machine outright, regardless of whoever happened to be logged in that day.
eDirectory held the Application objects, the policy packages, the workstation objects, and the associations and delegated rights connecting them — nothing more. The actual application files lived on controlled NSS distribution volumes, and the full hardware and software inventory lived in ZENworks’ own database on UnixWare, with only the narrow slice of object information the directory actually needed for policy and discovery represented there at all. Eric made the reasoning explicit for anyone who hadn’t sat through the same argument the year before: pouring every file signature, every scan result, every installation history into a replicated directory would repeat, almost exactly, the mistake the event-logging work had already refused to make.
The harder problem was inheritance, and Ruth wouldn’t let the room treat it as a footnote. A policy tied to a branch container could reach every workstation underneath it at once. A single group change could put an application in front of hundreds of users by lunchtime. That was the entire point of the design, and it was also, Ruth said flatly, exactly why she was requiring a preview before any association change took effect — a plain accounting of which users and which workstations a pending change would actually touch, shown to the administrator making it. The preview wouldn’t stop a mistake from happening. It would at least make sure nobody could claim afterward they hadn’t seen it coming.
One of Ruth’s own engineers pushed back, gently, on the cost of building the preview at all — computing the full effect of a pending change against a directory this size wasn’t free, and the customers most likely to make a careless change were exactly the ones least likely to wait for a slow screen to finish loading before clicking through it anyway. Ruth didn’t disagree with the cost. She just wasn’t willing to ship the alternative. “A fast tool that hides how far a change actually reaches isn’t faster,” she said. “It just moves the delay to after the mistake, where it costs a lot more than a few seconds ever would have.”
The Partner’s CNEs brought Front Range’s own banking application into the packaging lab the following week, and the vendor’s installer turned out to be exactly what everyone had warned it would be — built for one person sitting at one workstation, with no idea that a few hundred machines might need it delivered silently and all at once.
Documenting it properly took longer than anyone outside the lab expected: the application files and their exact versions, every Registry and configuration change the installer made along the way, the shared libraries it assumed were already present, which settings belonged to the workstation and which belonged to the individual user and needed to stay separate, the disk space and operating system it actually required, whatever Novell Client or Windows components had to exist first, the scripts that had to run before and after, whether a reboot was unavoidable, how the process could tell success from failure, and — the question that mattered most once something inevitably went wrong — what could be rolled back cleanly and what simply couldn’t. Nobody on Ruth’s team pretended a vendor’s installer could always be reversed without consequence; some of them rewrote shared files or local data in ways nothing could safely undo. The honest answer, when that happened, was to report the last proven state and stop, not to call a partial installation a success because nothing had technically thrown an error.
The first finished package ran cleanly on Windows NT and failed outright on an older Windows 95 workstation, because the two systems simply didn’t agree on the Registry, the services, or the files an installer could assume were there. Nobody tried to write one script clever enough to cover both. Ruth’s team built separate package paths behind the same single approved application identity instead, each one selected automatically once the workstation reported which system it actually was.
What the packaging lab proved, more than anything, was the limit of what any of this was actually for. ZENworks could distribute a vendor’s application faithfully. It couldn’t make that application portable, or correct, or supportable, simply by deciding to. The vendor stayed responsible for how its own software behaved. The Partner stayed responsible for the customer-specific package built around it. Novell’s own responsibility covered everything on its side of that line — the agents doing the installing, the inventory database recording what was actually out there, the policy engine deciding what applied to whom, the reporting anyone relied on to know the truth of it, the remote-management functions reaching into a workstation from a distance, and the documented, honest behavior of the whole product built around all of it — but it stopped exactly at the vendor’s own installer and the Partner’s own customer-specific package, neither of which Novell had written and neither of which Novell could promise to fix.
One of the younger CNEs, three days into cataloguing every Registry key the vendor’s installer touched, asked whether it wouldn’t just be faster to call the vendor and ask them to fix the installer properly instead of working around it by hand. Ruth’s own packaging lead, who’d had that exact conversation with more vendors than she cared to count, told him to make the call if he wanted to — and to let her know how it went. He didn’t bring it up again.
Curtis wanted all three versions fixed by the end of the week. Ellen wouldn’t authorize a bank-wide push until somebody could answer what happened to a teller transaction already in progress when the update arrived, a workstation without enough free disk space to hold the new package, a branch link that dropped in the middle of a transfer, and a machine that was simply powered off when the scheduled window opened.
What Ruth’s team built in response was a staged sequence rather than a single button. Inventory came first, touching nothing. Machines were sorted by operating system, hardware readiness, installed version, branch, and business function. The package was tested against lab copies of every configuration that sorting actually turned up. A small internal group and one noncritical branch got it before anyone else did. The large files crossed each branch’s own link overnight, pre-staged well before a single user needed them, and every package was verified complete against its own prerequisites locally before installation was ever allowed to begin. Installation itself ran inside a defined maintenance window, its prerequisites serialized and any required reboot held until the approved moment — and every outcome got recorded honestly as success, known failure, or simply not confirmed, because a silent workstation was not, under any circumstance, the same thing as a successful one.
A machine that was disconnected or powered off when its window came stayed pending. It didn’t count as a failure, and nobody was allowed to quietly drop it from the total just because it complicated the number. A workstation that lost its network connection partway through a transfer was never permitted to begin installing from whatever incomplete files had already arrived.