How Edrak cut a managed IT provider’s median resolution time from 9 hours to 90 minutes

The company

The provider manages IT infrastructure, cloud environments and end-user support for more than 70 organizations across the region, from mid-size firms to large enterprises with regulated workloads.

Its service desk receives roughly 11,000 tickets a month: password resets, access requests, device and network faults, software issues, and changes to client environments.

Every ticket carried a service-level commitment. Most also carried a hidden cost: the time engineers spent understanding the ticket before they could work on it.

Every ticket began with the same questions

Before an engineer could act, they had to establish context.

• Which client, which contract, which service-level commitment
• Which systems and users the ticket touched
• Whether the issue had occurred before, and what fixed it
• Whether a change was already scheduled that explained the symptom
• What the client’s environment permitted the engineer to do

The answers lived in the ticketing system, monitoring tools, configuration records, contract documents and the memory of whoever had handled the client last.

Tickets bounced between queues while that context was assembled. Escalations arrived at senior engineers as one-line summaries, and the investigation started again from the beginning.

Starting with the service desk

The provider deployed Atlas around one process: the intake, triage and preparation of every service-desk ticket.

Foundry connected the sources engineers already used:

• The ticketing system and its full history
• Monitoring and alerting platforms
• Configuration and asset records per client
• Client contracts and service-level commitments
• Runbooks, known-error records and past resolutions
• Change calendars for each environment

The provider defined severity rules, escalation paths and the boundary between what Atlas could prepare and what engineers must approve.

Atlas learned how the desk already worked and took over the assembly work around it.

From raw ticket to prepared work

When a ticket arrived, Atlas classified it, matched it to the client’s contract and service levels, and pulled the relevant environment records.

It checked monitoring data for related alerts, searched past tickets for the same symptom, and reviewed the change calendar for anything that could explain it.

For routine requests covered by a runbook, Atlas prepared the resolution end to end: the steps, the affected systems, the rollback path. The engineer reviewed and approved; the work executed.

For faults that needed investigation, the engineer opened a ticket that already contained:

• The client, contract and service-level clock
• The affected systems and their current state
• Related alerts and recent changes
• Past occurrences and what resolved them
• A proposed diagnosis with its supporting evidence

Escalations carried the full investigation with them. Senior engineers started from the evidence, never from a one-line summary.

Engineers stayed in control of client systems

The provider operates inside other companies’ infrastructure. It did not want AI executing changes on client systems without review.

Atlas was configured so that engineers remained responsible for:

• Approving every change before it executed
• Confirming diagnoses on faults affecting production systems
• Deciding escalations and client communications on major incidents
• Reviewing any action outside an approved runbook

Every action carried its authority, evidence and author in the audit log, per client and per environment.

Speed came from removing the assembly work, never from removing the review.

Measured against the prior quarter

The provider ran Atlas on two client queues for eight weeks, then compared performance across its full ticket volume against the previous quarter’s data.

• Median resolution time for routine requests fell from 9 hours to 90 minutes, measured across all clients on the same ticket categories
• Median time to a substantive first response fell from 34 minutes to 4, a response containing the diagnosis or next step, never an acknowledgment
• 100% of tickets arrived triaged and enriched before an engineer opened them
• Repeat investigations of known issues dropped to near zero, because past resolutions surfaced automatically
• 100% of changes on client systems retained engineer approval, confirmed by the audit log

Service-level performance improved without adding headcount, and the desk absorbed two new client contracts with the same team.

A different role for engineers

Before Atlas, engineers spent their shifts reading, searching and re-typing context between tools.

After deployment, their time concentrated on the work that needed them: diagnosing unusual faults, hardening client environments and handling the incidents where judgment matters.

Senior engineers stopped receiving escalations that restarted from zero. Client-facing reports drew on the same records the work produced, with no separate assembly step.

Every resolution makes the next one faster

Foundry retained each diagnosis, fix and outcome, linked to the client, systems and symptoms involved.

When the same symptom appeared again, anywhere in the client base, Atlas retrieved what had worked, checked whether the environment matched, and presented it to the engineer.

Resolution knowledge stopped living in individual engineers’ memories. It became part of how every ticket is handled.

Extending the operating model

With the service desk running, the provider began applying Atlas to adjacent workflows:

• Client onboarding and environment documentation
• Patch and change-window preparation
• Monthly client service reports
• Incident post-mortems and known-error records
• Contract-renewal usage summaries

Each follows the same model: Atlas assembles, prepares and drafts; engineers review, approve and stay accountable.

The outcome

The provider needed its engineers’ time to go into engineering rather than into assembling context.

Atlas and Foundry cut routine resolution times by a measured factor of six, put a case file behind every ticket, and kept every change on client systems under engineer approval.

The desk answers faster. The engineers do harder work. The clients see both.