Skip to content
02 / HOW WE WORK

No black box.
A clear process.

We review before we commit. We document before we take over. And we agree on what happens with changes and incidents.

PROCESS / OVERVIEW

From first contact to well-organized operations.

1REQUEST2CALL3CHECK4DECISION5HARDENING6HANDOVER7OPERATIONS8EXIT

Amber = still open, Green = reviewed/organized. Coral is used only for actual incidents or risks. The exit is optional and part of being ready for handover.

01 / REQUEST

Request

What happens: You describe the application, its purpose, hosting and current concerns.

What we need: A short system description, a contact person, no credentials.

What you get: An assessment of whether RTT is a fit in principle.

Time frame: Usually a few business days until we schedule a call; no service promise.

What exactly happens in this step
  • Capture the type of application, its purpose and its users
  • Ask about any acute incident risk
  • Record hosting and repository location
  • Roughly assess business criticality
  • Identify the responsible contact person
  • Check whether the stack qualifies in principle

Artifact: request profile / pre-qualification

Decision point: RTT decides whether an initial call makes sense.

What you can do in the meantime: Put together a short description, but don't send any credentials.

02 / INITIAL CALL

Initial call

What happens: We clarify criticality, stack, operating model and review needs.

What we need: A business and a technical contact, a rough architecture.

What you get: A proposal for the scope of the Operations Check.

Time frame: 30 minutes, free of charge.

What exactly happens in this step
  • Sketch system boundaries and data flows
  • Name the business and technical owners
  • Ask about the current deployment path
  • Understand availability needs and the impact of outages
  • Record hosting and data locations
  • Plan audit access and approvals
  • Define audit scope and exclusions

Artifact: audit scope and statement of work

Decision point: Client and RTT approve the review scope and the fixed-price range.

What you can do in the meantime: Bring a rough architecture and your most critical user flows.

03 / OPERATIONS CHECK

Operations Check

What happens: We review the repository, infrastructure, security, backups and deployments.

What we need: A non-disclosure agreement, time-limited read access to repository and infrastructure, existing documentation.

What you get: A status report, prioritized findings and a takeover recommendation.

Time frame: Usually one to two weeks, depending on the size of the system.

What exactly happens in this step
  • Clone the repository in an isolated environment and reproduce the build
  • Dependency audit matching the stack (npm audit, bundler-audit, pip-audit)
  • Secrets scan across current files and Git history
  • Trace the deployment path and rollback
  • Prove backup and restore in an isolated environment
  • Check health endpoints and alerting
  • Assess logs and retention
  • Inventory access and permissions
  • Capture data flows and protection needs
  • Document single points of failure and ownership gaps

Artifact: status report v1 with traffic-light rating and prioritized list of findings

Decision point: RTT recommends takeover, hardening under conditions, or declining; the client decides on the measures.

What you can do in the meantime: Provide the agreed read-only access and answer business questions promptly.

04 / DECISION

Decision

What happens: We assess the risks and agree on the way forward together. A no is possible, too.

What we need: Risk sign-offs, internal responsibilities and a budget range.

What you get: A decision on measures and takeover.

Time frame: Depending on the findings: from a few days to several rounds of coordination.

What exactly happens in this step
  • Prioritize critical findings by potential damage
  • Formulate acceptance criteria for taking over operations
  • Name remaining risks and owners
  • Estimate measures as workable work packages
  • Put hosting and stack boundaries in writing
  • Check service hours and the escalation path realistically
  • Negotiate liability and service limits

Artifact: decision log and prioritized action plan

Decision point: RTT may decline; the client decides on budget and remaining risks.

What you can do in the meantime: Name one decision-maker for business risks and budget.

05 / HARDENING

Hardening

What happens: We close the prioritized operational risks.

What we need: Test access, approvals, technical contacts.

What you get: Verifiable measures and the remaining risks.

Time frame: Depending on the findings: days to several weeks or longer.

What exactly happens in this step
  • Rotate secrets and manage them outside the repo
  • Set up CI/CD reproducibly
  • Separate staging and test data
  • Test dependency and security updates
  • Build health checks, alerts and central logs
  • Configure automatic backups and a restore test
  • Practice rollbacks under controlled conditions
  • Prepare the runbook and escalation list
  • Have changes accepted by the business side

Artifact: hardening log with evidence and an updated runbook

Decision point: RTT checks the technical minimum standards, the client signs off on the remaining risks.

What you can do in the meantime: Test critical business workflows on staging and give the defined approvals.

06 / HANDOVER

Handover

What happens: We set up operating procedures, alerting, the runbook and contacts.

What we need: Binding approvals, operational data and escalation contacts.

What you get: A documented handover of operations with an agreed scope of service.

Time frame: Usually several rounds of coordination; the exact duration depends on the system.

What exactly happens in this step
  • Set up operations access with least privilege
  • Switch on monitoring and alert recipients
  • Walk through the runbook with real procedures
  • Confirm the responsibility matrix together
  • Sign off restore and rollback evidence
  • Test the incident channel and escalation contacts
  • Document service hours, SLA and exclusions
  • Record exit and export paths

Artifact: operations contract + SLA, responsibility matrix and handover log

Decision point: RTT only takes over after documented approval and secured on-call coverage for the agreed scope.

What you can do in the meantime: Confirm contact channels, business owners and the agreed service windows.

07 / ONGOING OPERATIONS

Ongoing operations

What happens: Monitoring, maintenance, updates, incidents and reporting as agreed.

What we need: Change approvals, contacts and ongoing coordination.

What you get: A regular report and a traceable service operation.

Time frame: An ongoing service within the contractual service hours.

What exactly happens in this step
  • Check monitoring and alerts daily within the agreed window
  • Classify and log incidents
  • Review planned updates and changes
  • Run backups and restore tests as per contract
  • Recertify access permissions regularly
  • Create a monthly report with findings and changes
  • Update the runbook after incidents
  • Assess open risks with the client

Artifact: monthly report, incident logs and an up-to-date runbook

Decision point: The client decides on business changes and priorities; RTT is responsible for the agreed technical operation.

What you can do in the meantime: Approve changes in good time and report anything unusual through the agreed channel.

08 / EXIT ON REQUEST

Exit on request

What happens: We organize the handover to you or to a new operator.

What we need: Recipient, access routes, handover date and data export requirements.

What you get: Code, data, infrastructure documentation, runbook and handover log.

Time frame: Depending on scope and contract: usually days to several weeks.

What exactly happens in this step
  • Hand over code and repositories completely
  • Create a data export in the agreed format
  • Document the infrastructure configuration and dependencies
  • Update the runbook and recovery plan
  • Transfer access and ownership
  • Log open incidents and risks
  • Hold a handover meeting and answer questions
  • Revoke RTT access traceably

Artifact: exit package and signed handover log

Decision point: The client confirms receipt and takes over or names a new operator.

What you can do in the meantime: Name the future operator early and test the data import.

RESPONSIBILITY / CLARITY

Who does what?

AreaClientRTTTogether
Source code & application logicResponsible for content/rightsReview of changes relevant to operationsDocument limits
InfrastructureOwner / approvalOperation as per contractArchitecture and cost basis
Data & data protectionControllerTechnical measures within the agreed scopeDPA, deletion and export
AccessNaming/authorizationTechnical administration as mandatedLeast privilege & rotation
UpdatesBusiness acceptanceReview, planning, implementation within scopeChange approval
IncidentsImpact/business priorityDetect and respond as per SLAEscalation and post-incident report
Further developmentProduct ownershipOnly if separately commissionedReview and release approval

This matrix illustrates the split. Only the service and responsibility matrix agreed per system is binding.

OPERATIONS / STAYING FLEXIBLE

Incidents, changes and a clean exit.

INCIDENT RESPONSE

When it's not running.

Detect → Classify → Respond → Fix → Post-incident report.

● GREEN / operational: Normal operation confirmed.

● AMBER / unclear: Cause or impact still unclear.

● CORAL / incident: Confirmed incident or concrete risk.

Handling follows the actual service hours and escalation rules.

CHANGE CONTROL

AI code needs approval, too.

Submit change → code/dependency review → tests and staging → business approval → controlled deployment → monitoring → rollback if needed.

No straight prompt-to-production run without a review and fallback path.

How we set up the test pipeline: the Automate building block →

ONBOARDING SECURITY

Access doesn't belong in emails.

Don't send secrets and credentials via a form or unencrypted email. Access is granted through an agreed secure channel; time-limited least-privilege accounts, separate roles and the four-eyes principle for critical actions.

EXIT READY

No artificial lock-in.

Within the agreed scope, you get source code, a data export, an infrastructure description, a runbook, an access overview and a handover log. The time frame is agreed in advance based on the size of the system – no blanket guarantee of days.

ARTIFACTS / PREVIEW

Not just conversations. Documented results.

Schematic samples – no real client data or real operating figures.

Status report

RTT / STATUS REPORTSystem file: name of the system · As of: dateBackup / RestoreSecrets / CredentialsMonitoringUNCLEARRISKVERIFIEDPriorities + owners per finding

Monthly report

RTT / MONTHLY REPORTReporting month: month / yearUptimeUpdates appliedIncidentsNext stepsin %CountCountprioritizedStatus: Operational
TIME FRAME / ILLUSTRATIVE

A possible onboarding.

CheckDecisionHardeningHandoverW0W1W2W3W4W5W6W7W8Illustrative example · duration and dependencies vary

The bars show ranges and overlaps, not fixed commitments. An incident or missing access can change the approach.

FIRST MONTH / PROPOSAL

What we do after the takeover.

Sample rhythm, to be agreed per system before signing the contract.

DAY 1

Monitoring live

Test checks and alert routes, confirm contacts.

WEEK 1

Restore test

Verify recovery in an isolated environment and log it.

WEEK 2

Dependency review

Assess updates, agree on change windows and tests.

WEEK 4

First report

Summarize incidents, updates, risks and next measures.

RTT / NEXT STEP

Building it isn't running it.

We review first, before we take on responsibility.

Request an Operations Check ↗