Skip to content
Al Khobar, Saudi Arabia

L2 L3 support services

The engineers your helpdesk escalates to when the fault is real

Your first line can reset passwords and log tickets. When the fault sits in the code, the database or an integration, it needs an engineer who can read all three. We staff that second and third line.

3

support levels with clear hand-off rules

1 to 2 weeks

to take over escalations from your first line

2

languages for incident reports

L2 application diagnosisL3 code-level fixesDatabase and query tuningIntegration fault tracingLog and trace analysisHotfix and patch releasesRoot cause reportsVendor escalation handlingPerformance investigationEscalation hand-off rules

The direct answer

L2 and L3 support is the engineering layer behind a service desk. L2 diagnoses issues the first line cannot solve, using logs, configuration and data. L3 changes code, schemas or integrations to remove the cause. It suits companies with a helpdesk but no in-house engineers on call, and we agree escalation rules and response tiers up front.

Before and after

What this removes.

Escalations bounce between teams

Today

The helpdesk passes a ticket to IT, IT passes it to the vendor, and three days later nobody has opened the logs.

With the system

A named L2 engineer picks it up on escalation and either fixes it or hands it to L3 with findings attached.

Fixes treat the symptom

Today

Someone restarts the service every Sunday night, and the real memory fault stays untouched for months.

With the system

L3 finds the cause in the code or the data, changes it, and the restart job is retired.

Your developers are firefighting

Today

The people who should be building the next release spend half the week answering production questions.

With the system

Production faults go to support engineers, and the build team keeps its plan.

No record of why it broke

Today

A major outage is fixed at night and by Monday nobody can say what actually happened.

With the system

Every P1 and P2 closes with a short root cause report: what failed, why, and what changes.

What we build

What lands in your hands.

L2 triage and diagnosis

Reproduce the fault, read logs and data, and separate user error from real defects.

L3 code and schema fixes

Change the application, the database or the integration to remove the cause.

Escalation rules

Written criteria for what moves from L1 to L2 to L3, and what each hand-off must contain.

Hotfix and release routine

Small, tested patches with a rollback plan, kept apart from the feature roadmap.

Performance investigations

Slow screens, slow reports, locked tables: measured, traced and fixed.

Root cause reports

A plain write-up after serious incidents, with the permanent change proposed.

In depth

How it works, and what to decide.

Where L2 ends and L3 begins

The levels are easy to blur, so we write the boundary down. L1 is your service desk: logging, password resets, known-answer questions. L2 is diagnosis. An L2 engineer reproduces the problem, reads application logs and queries the data, checks configuration and recent releases, and decides whether it is a user issue, a data issue, a configuration error or a real defect. Most escalations end here with a configuration change, a data correction or a clear workaround.

L3 is for the cases where the cause sits in code, schema design or an integration contract. An L3 engineer changes the software, writes the test that would have caught it, and ships a patch through a controlled release. Each hand-off carries a defined package: steps to reproduce, what was already tried, relevant log lines and business impact. That discipline is what stops the ticket bouncing. We commit to response by severity, for example P1 response within 1 hour and P2 within 4 working hours, and we update at the cadence we agreed.

Access, data and the Saudi rules that apply

Engineers at this level need real access, and that is where discipline matters. We work on least-privilege accounts, log every session on production, and keep production data inside the boundary you set. Where a system stores personal data, PDPL puts duties on access, retention and breach handling, and we build those into the way we work. For financial or critical-infrastructure clients, controls from the NCA Essential Cybersecurity Controls and SAMA's framework often apply to third-party access, and we align our practice with the clauses your contract names.

We prefer to reproduce faults in a masked copy of production rather than debug on live data. Masking adds a few days to setup but removes a whole class of risk. If hosting must stay in the Kingdom, our work stays there too: we connect to the environment instead of exporting from it. All of this is written into the support agreement, so your compliance team can read exactly what an engineer can touch and how it is logged.

Pricing and what a good engagement looks like

L2 and L3 support is priced as a monthly retainer for an agreed number of engineering hours, with the hours split between reactive incidents and planned fixes. Incident volume is the main cost driver, followed by the age and documentation of the application. A well-kept modern system needs fewer hours than a ten-year-old customization nobody fully understands.

A good engagement shows a pattern. In the first two months, escalations are frequent as we clear the backlog of known problems. From month three the repeat causes are fixed, incidents drop, and hours shift from firefighting to preventive work: tuning slow queries, upgrading libraries, tightening alerts. We report that shift monthly, so you can see whether you are paying for fewer fires or just faster responses. If the numbers do not move, we say so and recommend either a rebuild of the weak area or a smaller retainer.

The delivery plan

Five stages. You sign off every one.

Read each stage as a small contract: what we need from you, what lands in your hands, and the sentence that has to be true before we move on.

01 / 04

Escalation design

3 to 5 days

We define the boundary between L1, L2 and L3 and the hand-off package for each, with your helpdesk lead.

What you do
  • Share your current ticket categories
  • Name the helpdesk lead and approvers
  • Pick the systems in scope
What we deliver
  • An escalation matrix
  • A hand-off template
  • A response table by severity
Exit criteria

We move on when your helpdesk can classify any ticket against the matrix without asking us.

02 / 04

Access and system review

1 to 2 weeks

We set up least-privilege access, read the code and data model, and review the last six months of escalations.

What you do
  • Grant scoped access
  • Provide architecture notes if any exist
  • Share past escalations
What we deliver
  • A system map
  • A list of recurring faults
  • A masked test environment plan
Exit criteria

We move on when engineers can reproduce a known past fault in a safe environment.

03 / 04

Backlog clearance

2 to 4 weeks

We work through the known open problems first, fixing the causes behind the most frequent tickets.

What you do
  • Prioritize the open problem list
  • Approve patch releases
  • Test fixes on staging
What we deliver
  • Fixes for the top recurring faults
  • Tested patch releases
  • Root cause reports for major items
Exit criteria

We move on when the top recurring faults are either fixed or have an agreed plan and date.

04 / 04

Steady-state support

ongoing

We take escalations against the response table and shift hours toward prevention as incident volume falls.

What you do
  • Escalate using the hand-off template
  • Attend the monthly review
  • Approve preventive work
What we deliver
  • Escalation response and fixes
  • A monthly report on causes and hours
  • Preventive work proposals
Exit criteria

We move on when the monthly report shows fewer repeat incidents and you approve the next preventive items.

Buyer questions

Asked before signing.

What is the difference between L2 and L3 support in practice?

L2 diagnoses a problem using logs, data and configuration, and often resolves it with a setting change or data fix. L3 changes the code, database design or integration when the cause lies there. We write the boundary and hand-off rules into the agreement.

Can you work alongside our existing helpdesk and ticket tool?

Yes. We use your ticket tool where possible, or give you one if you have none. Your first line stays yours, and we agree what an escalation must contain so tickets reach an engineer with enough detail to act on.

Do your engineers need access to our production data?

Sometimes, but we avoid it where we can. We prefer to reproduce faults in a masked copy, use least-privilege accounts, and log production sessions. Access terms are written into the agreement so your compliance team can review them.

Can you fix software we did not build?

Yes. We spend the first weeks reading the code and the data model, then fix what we find. If the source code is not available, we say so early, because that limits L3 work to configuration, integration and workarounds.

How quickly will you respond to a serious incident?

We agree response tiers by severity. A typical P1 is acknowledged within 1 hour in agreed cover hours, with regular updates until a workaround or fix lands. We do not promise a fix time, because the cause decides that.

Get engineers behind your hardest tickets

Send us the five escalations that cost you the most time last quarter. We will tell you which level each belongs to and what a retainer would look like.