Data Sovereignty: Architecture Before Extraction | S23k
ZAA Playbook · Data Sovereignty

Data Sovereignty: Architecture Before Extraction

How to recover architectural knowledge after years of outsourcing

Data sovereignty doesn't begin with data extraction. It begins with recovering architectural knowledge that has gradually eroded. This is objectively complex and requires investment.

This playbook provides realistic timelines (8-18 months), concrete costs (€110-200k excluding egress), and multiple paths with trade-offs. No quick wins, no oversimplification. A realistic picture of what data sovereignty demands in practice.

What you'll find here: How architectural knowledge erodes during outsourcing. Which complexity you actually need to address. Concrete tools for architecture recovery. Realistic budgets and timelines. An interactive egress cost calculator. And a go/no-go framework to determine if this is the right time.

The Ownership Illusion

Most organizations believe they own their data because they're contractually the owner and regularly make backups. That assumption holds legally but falls apart as soon as you try to move that data, migrate it, or bring it under different governance.

Real ownership means operational control — the ability to autonomously decide about location, access, processing and lifecycle of your data without depending on specific vendors, platforms or external parties who possess critical architectural knowledge.

Ownership Spectrum: Perceived vs. Actual
Fully outsourced
Contract + backups
Documented architecture
Operational autonomy
No control Legal ownership Operational knowledge Full autonomy

How Architectural Knowledge Disappears

Outsourcing is a rational decision: you buy in expertise, avoid recruitment risks, and get predictable costs. But architectural knowledge erodes gradually:

  • Year 1-2: Internal teams learn the new environment but lean on the partner for more complex questions.
  • Year 3-5: Original architects have left or moved to other roles. New colleagues only know the outsourced situation.
  • Year 5+: Critical knowledge exists only with the partner: dependencies between systems, historical design decisions, workarounds for specific edge cases.

This isn't a failure — it's economic logic. The partner maintains architectural knowledge because that's their business model. Your organization invests in other priorities.

The Moment of Realization

The illusion typically breaks at three moments: (1) An RFP for migration delivers quotes 3-5x higher than expected. (2) A compliance audit asks for data lineage documentation that isn't available. (3) A strategic pivot requires data integration that nobody internal can scope.

Why This Matters for Sovereignty

Sovereignty without architectural knowledge is legal ownership without operational control. You can be contractual owner of your data, but if you don't know where it lives, how systems interact with it, who has access and through which paths — then you don't have meaningful sovereignty.

This playbook treats architecture recovery as a precondition for data extraction. First understand what you have, then decide what to do with it.

The Complexity You're Facing

Architecture recovery isn't about copying data. It's about reconstructing understanding of three layers that have been abstracted during outsourcing: fragmentation (where everything lives), segmentation (who has access), and correlation (how it connects).

2.1 Fragmentation: Where Everything Lives

Data spreads over time. New services get added, old ones keep running, dev/test/prod environments diverge. After years of outsourcing you no longer have a complete picture of where which data actually lives.

💾

Storage Layers

  • Primary databases (transactional)
  • Data warehouses (analytical)
  • Blob/object storage (files, backups)
  • Caches and message queues
  • Log aggregation systems
🌐

Environments

  • Production (live data)
  • Staging/pre-prod (near-live)
  • Development & test (copies)
  • Disaster recovery (sync'd replicas)
  • Archival storage (compliance)
🏗️

Service Types

  • Managed services (PaaS)
  • IaaS with self-managed DBs
  • Containerized workloads
  • Serverless functions
  • Hybrid on-prem connections

What Fragmentation Means for Extraction

You can't "just export the database" — you must first identify which databases, in which environments, with which replicas, which dependencies, and which retention policies. Managed services often have vendor-specific export procedures. Blob storage can contain millions of objects without logical structure. Caches and queues contain transient data that may or may not be relevant.

2.2 Segmentation: Access and Boundaries

Access control works in layers. Users have permissions, services have identities, networks have firewalls, data has encryption. All those layers must be reconstructed to understand who/what has access and through which paths.

👤

User Layer

  • Employee accounts (IAM/AD)
  • Service accounts (automation)
  • External partners (B2B access)
  • Admin/emergency access (break-glass)
  • Orphaned accounts (turnover)
🔐

Service Layer

  • Managed identities (Azure/AWS/GCP)
  • API keys and secrets
  • Service principals (app registrations)
  • Cross-service permissions
  • Temporary credentials (STS/tokens)
🛡️

Network Layer

  • VPN/private endpoints
  • Firewall rules (IP whitelists)
  • Virtual network peering
  • Service endpoints
  • Public vs. private access
🔒

Encryption Layer

  • Encryption at rest (keys, HSM)
  • Encryption in transit (TLS/certs)
  • Customer-managed keys (CMK)
  • Key rotation policies
  • Key access permissions

Segmentation as Migration Blocker

If you don't know which service accounts have access to which resources, you can't shut down systems without outages. If encryption keys are vendor-managed, you can't decrypt data outside that environment. If network access runs through private endpoints, standard export tools won't work. Segmentation must be made explicit before extraction can begin.

2.3 Correlation: Dependencies and Flows

Systems don't exist in isolation. They call each other, share data, trigger processes. Those dependencies are often implicit — they're not in documentation but exist as runtime behavior.

🔄

Synchronous Dependencies

  • API calls between services
  • Database queries (cross-DB)
  • Authentication flows (SSO chains)
  • Real-time data lookups
  • Validation services
⏱️

Asynchronous Dependencies

  • Message queues (pub/sub)
  • Scheduled jobs (cron/batch)
  • Event-driven triggers
  • Data replication (sync/async)
  • Backup/archival processes
🔌

Data Flows

  • ETL/ELT pipelines
  • Data lake ingestion
  • BI/reporting queries
  • ML model training/inference
  • Audit logging streams

Why correlation is hardest: Dependencies are often undocumented because they grew organically. A service calls an API that was added two years ago for a specific use case. A batch job reads data from a table that was actually meant for something else. A report query does a join across three databases. All those implicit connections must be made explicit.

Discovery Approach for Correlation

You can't extract this from documentation — it must come from runtime observation: network traffic analysis (what talks to what), authentication logs (who/what logs into which resources), query logs (which queries touch multiple systems), and API gateway metrics (which endpoints get hit). This requires instrumentation and time — typically 4-8 weeks continuous monitoring to identify patterns.

Egress Costs: The Hidden Tax

Cloud providers don't just charge for storage and compute — they also charge for data leaving their network. This is called egress (or data transfer out), and it's often the biggest surprise in a migration quote.

How Egress Pricing Works

Egress costs are tiered: the first X GB per month is free or cheap, then prices rise in tranches. This means small datasets (< 100 GB) are relatively cheap, but once you start moving terabytes, costs rise exponentially.

Provider differences:

  • Azure: First 100 GB/month free, then €0.075/GB (up to 10 TB), €0.065/GB (10-50 TB), declining to €0.043/GB (>150 TB).
  • AWS: First 100 GB/month free, then €0.09/GB (up to 10 TB), €0.085/GB (10-50 TB), declining to €0.05/GB (>150 TB).
  • GCP: First 200 GB/month free (only provider that does this), then €0.085/GB (up to 1 TB), €0.08/GB (1-10 TB), declining to €0.05/GB (>150 TB).

Real-world Example: SAP on Azure

Say you have 20 TB of SAP data (8 TB HANA database, 6 TB application data, 6 TB backups). Extraction via internet: 20,000 GB × €0.075 (first tier) = €1,500 for first 10 TB, + 10,000 GB × €0.065 = €650 for second tier. Total: €2,150 for egress alone. Transfer time at 1 Gbps sustained: ~44 hours. At 100 Mbps (more realistic): 18+ days.

Alternatives for Large Volumes

For datasets > 10 TB there are often physical transfer options:

  • Azure Data Box: 80 TB disk array, ~€300 shipping + handling, no egress costs.
  • AWS Snowball: 50-80 TB devices, ~€250-400 per device, no egress costs.
  • GCP Transfer Appliance: 40-300 TB, pricing on request, no egress costs.

Physical transfer is often cheaper for volumes > 10 TB, but adds 1-2 weeks to the timeline (shipping, loading, return shipping, data import).

Egress Cost Calculator

Calculate your expected costs and transfer time

2.4 External Access: The Invisible Architecture

Most architecture documentation describes internal systems: databases, applications, networks. But there's a layer that's often completely missing: who has external access to your systems?

External access accumulates over time. A partner gets VPN access for a migration. A consultant gets database access for a performance audit. A vendor gets SFTP access for data exchange. These access paths often persist long after the original purpose has expired.

Why External Access Matters for Sovereignty

You cannot be sovereign over infrastructure if you don't know who has access to it. External access isn't just a security concern — it's an architectural dependency. If an external party has access, they also have leverage. They can use systems in ways you don't anticipate. They can create dependencies that complicate migration.

Real scenario: External access as migration blocker

Organization wanted to migrate from Azure to on-prem. During discovery, it emerged that 12 external parties had direct database access (via private endpoints + IP whitelisting). None of these parties were documented in the architecture documentation. Migration required: (1) identify all parties, (2) design alternative access paths, (3) migrate parties to new access methods, (4) phase out old access. This added 4 months to the timeline.

Types of External Access

🔐

VPN / Network Access

  • Site-to-site VPN connections
  • Point-to-site VPN (individual users)
  • Private peering (ExpressRoute, Direct Connect)
  • IP whitelisting on firewalls
  • Bastion hosts / jump servers
🔌

API / Service Access

  • API keys for partners
  • OAuth2 client credentials (B2B)
  • Service principals with permissions
  • Webhooks to external systems
  • Event subscriptions (pub/sub)
👨‍💼

Admin / Support Access

  • Vendor support accounts (Microsoft, SAP)
  • Managed service provider access
  • Emergency break-glass accounts
  • Consulting team temporary access
  • Audit firm read-only access
📁

File Transfer / SFTP

  • SFTP accounts for data exchange
  • FTP/FTPS legacy connections
  • Managed file transfer platforms
  • Cloud storage shared folders
  • Email-based file sharing
🗄️

Database Direct Access

  • Read-only accounts for reporting
  • Integration user accounts
  • BI tool service accounts
  • Data science team access
  • Legacy application connections

Discovery: External Access Audit

You can't extract external access from documentation — it must be reconstructed from logs, firewall rules, IAM policies, and interviews. Here's the approach:

Step 1: Network Layer (2-3 weeks)

  • VPN connection logs (who connects from where?)
  • Firewall whitelist rules (which external IPs have access?)
  • Private endpoint configurations (which services are exposed?)
  • Network flow logs (who talks to which resources?)

Step 2: Identity Layer (2-3 weeks)

  • IAM audit (all users, service principals, API keys)
  • Authentication logs (who logs in from external IPs?)
  • Permission assignments (which external identities have access?)
  • Federated identity mappings (external IdPs)

Step 3: Application Layer (1-2 weeks)

  • API gateway logs (which keys are being used?)
  • Webhook configurations (where do we send events?)
  • Database connection logs (non-internal IP ranges)
  • File transfer logs (SFTP/FTP activity)

Step 4: Validation (1 week)

  • Cross-reference with contract database
  • Interview key stakeholders (who knows about this access?)
  • Business justification per access path
  • Risk classification (critical / important / legacy)

Output: External Access Registry

Deliverable is a spreadsheet with: Party Name | Access Type | Systems Accessed | Business Purpose | Established Date | Last Used | Owner | Risk Level | Decommission Plan.

This document becomes part of your architecture documentation and should be updated quarterly.

Migration Impact

Every external access path must be migrated or deactivated. This isn't technical trivia — it's stakeholder management across multiple organizations:

Pre-migration (2-4 months before go-live):

  • Notify all external parties of planned changes
  • Design alternative access paths in new architecture
  • Test new access methods with each party
  • Obtain sign-off that new access works

During migration:

  • Maintain old and new access paths temporarily in parallel
  • Monitor both paths for activity
  • Communicate cut-over timing per party

Post-migration (1-2 months):

  • Deactivate old access paths incrementally
  • Verify that no party still uses old paths
  • Document new access architecture
  • Update contracts where needed

Budget €5-10k for coordination effort, plus 2-3 FTE-weeks internal time for stakeholder management.

2.5 Identity Lifecycle: Rights Accumulate, Never Decrease

Here's an uncomfortable truth: identity management accumulates rights but almost never removes them. People get access during onboarding. They get additional rights during role changes. They get elevated access for specific projects. But those rights are rarely revoked.

After 5-7 years, an average enterprise has 40-60% "orphaned accounts" — accounts that exist, are sometimes still active, but no longer have a clear owner or purpose. This isn't just a security risk; it's an architectural blocker for sovereignty.

How Access Accumulates

Phase 1: Onboarding
New employee gets basic access: email, intranet, basic applications. This is usually well documented and follows a process.

Phase 2: Role Changes
Person changes departments. Gets new access for new role. But old access isn't revoked "just in case" or because nobody is responsible for it. Now the person has 2 sets of rights.

Phase 3: Project Elevation
Person works temporarily on project requiring elevated access (admin rights, production access, direct database access). Access is granted "for the duration of the project". Project ends. Access remains.

Phase 4: Departure
Person leaves organization. HR process ensures account disablement in primary systems (AD, email). But access in satellite systems — cloud subscriptions, SaaS tools, database accounts, API keys — often persists because these aren't centrally managed.

Real scenario: 847 accounts, 312 users

SAP landscape audit: 847 user accounts, 312 current employees. Of the 535 "extra" accounts: 180 former employees (accounts disabled but not deleted), 95 consultants who worked on projects 2-5 years ago, 140 service accounts without owner, 85 test accounts, 35 completely unexplained ("who is this?"). Cleanup took 6 weeks fulltime for two engineers.

Special Cases That Make It Worse

Contractors & Temps
Short-term contracts (3-6 months) often get the same access as employees for "efficiency". At contract end, there's no formal offboarding process. Result: contractor accounts persist for months or years, often with full production access.

Interns
Interns get access, usually well monitored during their internship. But after completion: account disabled in AD, but cloud resource access (Azure subscriptions, AWS accounts) often remains active because it doesn't run through AD.

Service Accounts
Created for automation, integrations, batch jobs. Often no documented owner. No expiration date. No review process. These accounts accumulate endlessly, because nobody knows if they're safe to remove.

Shared Credentials
"Team account" for database access. Password shared via Excel sheet or Slack. Nobody knows who has it. Impossible to revoke without impacting entire team.

M&A Leftovers
Company A acquires Company B. Systems are integrated. But identity systems aren't fully merged. Result: people have accounts in both legacy identity systems, often with inconsistent rights.

Why This Is Architecture (Not Just Security)

Identity lifecycle problems aren't just "we need better offboarding" — they're fundamental architectural challenges:

1. Attack Surface
Every orphaned account is a potential attack vector. Credential stuffing, password reuse, compromised contractor accounts — these are real breach scenarios. But from a sovereignty perspective: you can't claim control over your systems if you don't know who has access.

2. Sovereignty Measurement
"We control our infrastructure" isn't true if 40% of your accounts have no known owner. You can't be sovereign over something you don't have inventory of.

3. Migration Blocker
You can't migrate systems if you don't know which accounts are active and who uses them. You can't clean up accounts during migration (too risky — what if this is a critical service account?). Result: you migrate the problem along.

4. Compliance Nightmare
GDPR requires that you can demonstrate who has access to personal data. "We have 847 accounts but don't know who they all are" isn't an answer that auditors accept.

Discovery: Identity Audit

Identity cleanup begins with complete inventory. Here's the systematic approach:

Step 1: Account Enumeration (1 week)

  • All identity stores (AD, Azure AD, AWS IAM, database users, SaaS logins)
  • Service accounts (automation, integrations, batch jobs)
  • API keys and access tokens
  • SSH keys and certificates
  • Shared credentials (where documented)

Step 2: Activity Analysis (2-3 weeks)

  • Last login date per account (all systems)
  • Last password change (indicator of active management)
  • Recent activity (authentication logs, 90 days minimum)
  • Permission usage (which rights are actually used?)

Step 3: Ownership Mapping (2-3 weeks)

  • Match accounts to current employees (HR database)
  • Identify former employees (departed > 6 months ago)
  • Find service account owners (who created them, for what purpose?)
  • Flag orphans (no match to known person/system)

Step 4: Risk Classification (1 week)

  • Privilege level (admin vs. standard user)
  • Data access scope (production vs. dev/test)
  • System criticality (core business vs. support tools)
  • Exposure (internet-facing vs. internal only)

Step 5: Cleanup Plan (1 week)

  • Immediate deactivation (former employees, obvious orphans)
  • Short-term review (service accounts without owner → find owner or decom)
  • Long-term governance (prevent re-accumulation)

Deliverable: Identity Audit Report

Template: Username | System | Created Date | Last Used | Permission Level | Owner | Status | Risk Score | Action Plan

Expect: 30-50% of accounts have no clear owner. 20-30% are > 6 months inactive. 10-15% have elevated privileges without business justification.

Cleanup: Realistic Timelines

Week 1-2: Immediate Safety

  • Disable accounts of former employees (> 6 months departed)
  • Revoke admin rights without recent use (> 90 days)
  • Deactivate internet-exposed accounts without owner

Week 3-6: Systematic Review

  • Service account owner identification (1 per day pace)
  • Shared credential replacement (individual accounts)
  • Permission right-sizing (remove unused elevated access)

Week 7-12: Governance Implementation

  • Automated offboarding workflow (HR → IT → deactivation)
  • Quarterly access reviews (managers certify their team's access)
  • Service account registration process
  • Expiration dates on temporary elevation

Budget: €8-15k external support or 4-6 weeks internal FTE for initial cleanup. Ongoing governance: 1-2 days per month.

Governance: Preventing Re-Accumulation

Cleanup isn't enough — without governance you'll be back where you started within 12-18 months. Implement these controls:

1. Automated Offboarding
HR marks employee as "departed" → automated workflow disables all accounts within 24 hours. No manual intervention, no exceptions, no "we'll do it later".

2. Quarterly Access Reviews
Managers get list of accounts in their team. Must certify: "This person needs this access for this business reason". Not certified = auto-revoke.

3. Time-Bound Elevation
Elevated access (admin, production) always has an expiration date. After expiry: auto-revoke. New elevation requires re-justification.

4. Service Account Registry
Every service account must be registered: Owner | Purpose | Systems | Expiration. Annual review: still needed? Update ownership. No owner = decom.

5. No Shared Credentials
Zero tolerance policy. Shared access = personal accounts with group permissions. This makes it auditable who has access.

Migration Implication: Clean Before You Move

NEVER migrate without doing identity cleanup first. Why? (1) You migrate the problem along, (2) It gets worse (old + new systems = 2x the accounts), (3) Post-migration cleanup is 3-5x more expensive (systems running, fear of breaking something).

Rule: Identity audit + cleanup must be complete before Phase 4 (Pilot) of your migration begins.

3. Architecture Recovery Toolkit

Architecture knowledge recovery requires a combination of automated discovery tools, contractual knowledge extraction from partners, and parallel documentation building. Here are the concrete methods.

3.1 Automated Discovery Tools

Cloud providers offer native tools for infrastructure discovery. These give you a snapshot of your current state, but have limitations.

Azure:

  • Azure Resource Graph: Query all resources across subscriptions (VMs, databases, storage, networking). Gives you "what exists" but not "why" or "how it's used".
  • Azure Monitor: Metrics + logs for resource usage. Can infer dependencies from authentication logs and network flows.
  • Azure Advisor: Recommendations for optimization, but also insights into underutilized resources (candidates for decommissioning).
  • Cost Management: Follow the money — resources with consistent spend are probably actively in use.

AWS:

  • AWS Config: Continuous resource inventory + configuration history. Tracks changes over time (who created this, when, why).
  • AWS CloudTrail: API call logging — who does what, when. Essential for correlation discovery.
  • AWS Systems Manager Inventory: Detailed instance metadata (software, patches, configurations).
  • VPC Flow Logs: Network traffic analysis — which systems talk to each other.

GCP:

  • Cloud Asset Inventory: Search and analyze all GCP resources across projects.
  • Cloud Logging: Centralized logs for all services (authentication, API calls, resource access).
  • Network Intelligence Center: Network topology + performance visibility.

What Automated Tools Can and Cannot Do

Can: Inventory (what exists), Usage (what is active), Connectivity (what talks to what), Configuration (how is it set up).

Cannot: Business context (why does this exist), Ownership (who is responsible), Dependencies rationale (why is this connected), Future intent (is this permanent or temporary).

3.2 Partner Knowledge Extraction

Your managed service provider has architectural knowledge that isn't in documentation. Here's how to contractually extract that knowledge.

Contractual Rights:

  • Check your contract: do you have right to "knowledge transfer" at exit?
  • Do you have right to documentation updates (quarterly/annual)?
  • Is there a transition assistance clause (X days support after contract end)?

Structured Knowledge Transfer:

  • Architecture walkthroughs: Scheduled sessions (2-4 hours per major system) where partner architects explain your systems. Record these sessions.
  • Runbook extraction: Operational procedures, troubleshooting guides, escalation paths. This isn't architecture documentation but is equally critical.
  • Dependency mapping workshops: Partner knows the implicit dependencies. Force explicit mapping: system A calls B, why, how critical is that?
  • Incident postmortem access: Past incidents often have architectural root causes. Access to incident reports = architectural lessons.

Reality Check:

Partners have no incentive to give complete knowledge transfer if it threatens their future revenue. Expect:

  • Documentation that's accurate but not complete
  • Walkthroughs that stay high-level unless you ask specific questions
  • Runbooks that describe procedures but not rationale ("it works this way, so we do it this way")
  • Resistance to transfer of "specialized knowledge" (leverage for renegotiation)

Tactic: Begin knowledge extraction 12-18 months before planned exit/renegotiation. This gives you time to identify gaps and makes it less obvious you're preparing to exit.

3.3 Shadow Documentation

When partner-provided documentation is insufficient, you must build your own knowledge in parallel. This is called "shadow documentation" — reconstructing architectural knowledge independently of the partner.

Method 1: Runtime Observation

  • Deploy observability tools (Datadog, New Relic, ELK stack)
  • Monitor traffic patterns: which services talk to each other, how often, with what payloads
  • Analyze authentication flows: who/what logs into which resources, via which paths
  • Track database queries: which apps touch which tables, which queries are critical

Method 2: Configuration Archaeology

  • Git history analysis: who committed what, when, with what comment (context!)
  • Infrastructure-as-Code review: Terraform/ARM templates describe "as-built" state
  • Change tickets: JIRA/ServiceNow tickets for changes often have rationale
  • Email archaeology: search corporate email for discussions about systems (risky but effective)

Method 3: Tribal Knowledge Capture

  • Interview senior engineers: "Tell me about system X, why does it exist, what would break if it's gone?"
  • Create architectural decision records (ADRs): document every major decision with context, alternatives considered, rationale
  • Wiki-style documentation: lower threshold for contributions, iterate toward accuracy over time

Warning: Shadow Docs Require Discipline

Shadow documentation usually fails not from lack of effort, but from lack of maintenance. You create docs, they become outdated, within 6 months they're misleading.

Success factor: Automated validation. Scripts that test docs against runtime reality. "Doc says system A talks to B via port 443" → script tests if that's true → alerts if it diverges.

Toolkit Combination Strategy

Use all three methods in parallel:

  • Month 1-2: Automated discovery (fast, broad, incomplete)
  • Month 2-4: Partner knowledge extraction (deeper, contractually enforced)
  • Month 3-6: Shadow documentation (fill gaps, validation)

By month 6: You have automated inventory (what exists), partner docs (official view), shadow docs (validated reality). Cross-reference these three sources → architectural truth emerges where they overlap.

4. Capacity Assessment

Architecture recovery and data sovereignty require expertise. The question isn't "can we do this?" but "do we have the capacity to lead this without being completely dependent on external help?"

Here are three realistic scenarios based on your current internal capacity.

Scenario A: Cloud-Competent Internal Teams

Characteristics:

  • You have 2-3+ engineers with deep cloud experience (Azure/AWS/GCP certified, hands-on)
  • Team understands infrastructure-as-code, CI/CD, observability
  • There's an architect who can make multi-cloud comparisons
  • Team has already successfully led several smaller migrations

Approach:

You can lead architecture recovery and migration planning internally with tactical external support. Hire specialists for specific gaps (e.g. SAP-on-Azure expertise, enterprise networking), but core decisions and execution remain internal.

Timeline: 8-12 months (faster because less external coordination overhead)

Cost: €50-80k external (specialists on hourly/daily rate), rest internal capacity

Risk: Medium — you have expertise but possibly no experience with edge cases

Scenario B: IT Team Without Cloud Depth

Characteristics:

  • Strong traditional IT team (servers, network, databases)
  • Limited cloud experience (basics known, but no production deployments)
  • No in-house cloud architect
  • Team can learn but needs guidance

Approach:

Hire a cloud architect (contract, 6-12 months) who doesn't just advise but also trains your team. This person leads architecture recovery, makes decisions, but works explicitly on knowledge transfer to your team.

Timeline: 12-18 months (extra time for team learning curve)

Cost: €120-180k (architect €100-150/hour, 20-30 hours/week average over contract duration)

Risk: Medium-High — success depends on finding the right architect (technical + teaching skills)

Critical: Contract must explicitly contain knowledge transfer deliverables: documentation, training sessions, pair programming. This prevents the architect from leaving with all knowledge.

Scenario C: Fully Outsourced IT

Characteristics:

  • No internal IT engineers (or very small support-only team)
  • All infrastructure and applications managed by MSP
  • Internal team focuses on business/functional needs, not on technical
  • Sovereignty requires capacity you don't currently have

Approach — You have 3 options:

Option 1: Hire Architect + Begin Team Building

  • Start with one senior cloud architect (fulltime hire)
  • Architect leads recovery, recruits 2-3 engineers over 12-18 months
  • Parallel: transition from MSP-managed to hybrid (MSP support, internal ownership)
  • Timeline: 18-24 months (capacity building takes time)
  • Cost: €350-500k (salaries + recruitment + initial tooling)
  • Risk: High — recruitment is hard, team building is slow, MSP transition is complex

Option 2: Second Partner (Competition Dynamics)

  • Hire a second MSP to do architecture recovery
  • This creates competition (current MSP vs. new MSP) that forces transparency
  • New MSP has incentive to document current state (shows gaps of incumbent)
  • Timeline: 12-15 months (faster than building internal, slower than having it)
  • Cost: €80-150k (partner fees for discovery + documentation)
  • Risk: Medium — you trade dependency on one partner for dependency on two partners

Option 3: Accept Current State, Optimize Contracts

  • Realistic: maybe full sovereignty isn't the goal
  • Focus on contractual sovereignty: better exit clauses, knowledge transfer obligations, price protection
  • Remain outsourced, but with better leverage
  • Timeline: 3-6 months (contract renegotiation)
  • Cost: €15-30k (legal + consultant support for renegotiation)
  • Risk: Low execution risk, but you don't solve fundamental dependency

Honest Assessment: Scenario C Option 3 Is Often Realistic

If you have no internal IT capacity, building it is a multi-year commitment with significant financial investment and operational risk during transition. For many organizations, that's not a strategic priority.

Better question: "What is our actual sovereignty goal?" If the answer is "we want to be able to switch MSPs if pricing becomes unreasonable", then Option 3 solves that without complete transformation.

Capacity Reality Check

Be realistic about what capacity you have and what you can/want to build:

  • Cloud expertise is scarce and expensive: Senior cloud architects earn €100-150k+ salary. They're hard to find and retain.
  • Team building takes 18-24 months minimum: From "we have nobody" to "we have a competent team" isn't a 6-month trajectory.
  • Partial capacity is dangerous: One cloud engineer who has all knowledge = single point of failure. You need redundancy.
  • Maintaining capacity is ongoing cost: You must keep training, certifying, and technically challenging engineers or they'll leave.

Decision framework:

  • Scenario A → Proceed with confidence, tactical support only
  • Scenario B → Invest in architect + training, this is doable
  • Scenario C → Be critical whether full sovereignty is realistic, or if better contracts are sufficient

5. Timeline Expectations

Data sovereignty trajectories take 8-18 months, depending on complexity, internal capacity, and how complete your current architectural knowledge is. Here's the realistic phased timeline.

Phase 1: Discovery (6-12 weeks)

Deliverables:

  • Complete infrastructure inventory (all resources, all environments)
  • External access registry (who has access from outside)
  • Identity audit (all accounts, owners, risk classification)
  • Dependency mapping (which systems talk to each other)
  • Initial gap analysis (what don't we know?)

Activities:

  • Automated discovery tools deployment + data collection (week 1-2)
  • Log analysis for correlation discovery (week 2-6)
  • Partner knowledge extraction sessions (week 3-8)
  • Identity audit + external access mapping (week 4-10)
  • Synthesis + gap analysis (week 10-12)

Team: 2-3 engineers (internal) + 1 architect (external if needed), ~50% capacity

Cost: €30-45k (tooling + external support)

Phase 2: Assessment (4-8 weeks)

Deliverables:

  • Sovereignty score (use STM Scorecard)
  • Vendor dependency analysis (how locked-in are we?)
  • Jurisdictional risk assessment (which legal exposures?)
  • Egress cost calculations (realistic migration budget)
  • Capacity gap analysis (what must we learn/hire?)

Activities:

  • Apply STM framework to discovery data (week 1-2)
  • Model alternative architectures (multi-cloud, hybrid, repatriation) (week 2-5)
  • Cost-benefit analysis per scenario (week 4-6)
  • Risk assessment + mitigation strategies (week 6-8)

Team: 1 architect + 1 PM + finance stakeholder involvement

Cost: €23-37k (mostly internal time + some consulting)

Phase 3: Planning (6-10 weeks)

Deliverables:

  • Target architecture design (where are we going?)
  • Migration roadmap (which systems when, in what order)
  • External access transition plan (stakeholder comms + tech design)
  • Identity cleanup + governance implementation
  • Detailed budget (per phase, per workload)
  • Risk register + mitigation plan

Activities:

  • Architecture design workshops (week 1-3)
  • Migration sequencing (dependency-based ordering) (week 2-4)
  • External stakeholder engagement (notify partners of changes) (week 3-6)
  • Identity cleanup execution (week 4-8)
  • Detailed project planning (tasks, owners, timelines) (week 7-10)

Team: 2-3 engineers + 1 architect + 1 PM + executive sponsor involvement

Cost: €23-37k (planning + initial cleanup work)

Go/No-Go Gate After Phase 3

This is your decision point. You have: complete architectural knowledge, realistic cost estimate, concrete plan. Now decide: GO (proceed to pilot), NO-GO (stay but optimize contracts), or PAUSE (build more internal capacity first).

This is where many trajectories stop — and that's ok. Sometimes the conclusion is "this is too expensive/complex for our current priorities". Better to know now than halfway through a failed migration.

Phase 4: Pilot (4-8 weeks)

Deliverables:

  • 1-2 non-critical workloads migrated to target architecture
  • Runbooks tested and validated
  • Performance + cost verification (does it match estimates?)
  • Team skills validation (can we do this without partner?)
  • Lessons learned + plan adjustments

Activities:

  • Select pilot workloads (low risk, representative complexity) (week 1)
  • Execute migration (prep, move, validate) (week 2-5)
  • Monitor for 2 weeks (stability, performance, cost) (week 5-7)
  • Retrospective + plan updates (week 8)

Team: 3-4 engineers (fulltime for pilot duration) + architect oversight

Cost: €12-20k (pilot infrastructure + contingency)

Phase 5: Production Migration (3-12 months)

Deliverables:

  • All in-scope workloads migrated
  • Old infrastructure decommissioned
  • Documentation updated to reflect new architecture
  • Team trained on new operations
  • Monitoring + alerting operational

Activities:

This is the bulk work. Timing depends entirely on:

  • Number of workloads: 10 workloads = 3-4 months, 100 workloads = 9-12 months
  • Complexity: Databases with replication = slower, stateless apps = faster
  • Downtime tolerance: Zero downtime = slower (parallel run + cutover), acceptable downtime = faster
  • External dependencies: Many external access paths = more coordination overhead

Team: 3-5 engineers (depending on parallel workstreams) + PM + architect

Cost: €45-95k (excluding egress) — mostly internal time + infrastructure costs

Total Timeline: 8-18 Months

Scenario Timeline Key Factor
Best Case
Strong internal team, simple architecture, good existing docs
8-10 months Internal capacity + low complexity
Typical Case
Some internal capacity, moderate complexity, partial docs
12-15 months Discovery takes time, pilot reveals unknowns
Complex Case
Building internal capacity, high complexity, no docs
15-18 months Team learning curve + extensive discovery

Realism: Add 20-30% buffer to your estimate. Migrations always take longer than planned due to: discovered dependencies, stakeholder coordination delays, technical issues in pilot, team capacity fluctuations.

6. Budget Reality

Here are the concrete costs for data sovereignty trajectories, based on the phased timeline. All amounts are estimates — actual cost depends on scale, complexity, and internal vs. external resourcing mix.

Cost Breakdown Per Phase

Phase 1: Discovery (6-12 weeks)

  • Tooling: €5-8k (observability platforms, cloud cost tools, auditing software)
  • External support: €15-25k (architect for 10-15 days @ €1000-1500/day)
  • Internal time: €10-12k opportunity cost (2-3 FTE @ 50% capacity)
  • Total: €30-45k

Phase 2: Assessment (4-8 weeks)

  • Consulting: €12-20k (architecture assessment + scenario modeling)
  • Internal time: €8-12k (architect + PM + finance involvement)
  • Travel/workshops: €3-5k (if external stakeholders need in-person sessions)
  • Total: €23-37k

Phase 3: Planning (6-10 weeks)

  • Identity cleanup: €8-15k (tooling + external support OR 4-6 weeks internal FTE)
  • External stakeholder coordination: €5-10k (communication + validation effort)
  • Detailed design: €10-12k (architect + engineering time)
  • Total: €23-37k

Phase 4: Pilot (4-8 weeks)

  • Infrastructure: €3-5k (pilot environment costs)
  • Team time: €8-12k (3-4 engineers fulltime for pilot duration)
  • Contingency: €1-3k (unexpected issues, always happen)
  • Total: €12-20k

Phase 5: Production Migration (3-12 months)

  • Egress costs: HIGHLY VARIABLE (see Section 7 calculator — can be €500-50k+)
  • Infrastructure: €10-25k (new target environment, parallel run period)
  • Team time: €25-50k (3-5 FTE over duration, opportunity cost)
  • External specialists: €10-20k (for edge cases, performance tuning)
  • Total: €45-95k (EXCLUDING egress)

Total Budget Range

Realistic Total Investment

€110-200k (excluding egress costs)

This is for a typical mid-size organization (10-50 workloads, moderate complexity). Egress can add another €5-50k+ depending on data volumes.

Variables That Affect Cost

1. Internal vs. External Resourcing

  • More internal capacity = lower budget (but higher opportunity cost)
  • More external experts = higher budget (but faster + less learning curve risk)
  • Sweet spot: External architect + internal execution team

2. Architecture Complexity

  • Monolithic apps on VMs = relatively cheap (lift-and-shift possible)
  • Microservices with managed services = more expensive (more dependencies to map)
  • SAP/Oracle enterprise systems = significantly more expensive (specialized expertise required)

3. Downtime Tolerance

  • Acceptable downtime (weekend cutover) = cheaper (simpler migration path)
  • Zero downtime required = more expensive (parallel run, complex cutover, fallback planning)
  • Reality: Most organizations can accept some downtime for non-customer-facing systems

4. Data Volume (Egress Impact)

  • < 5 TB total = egress is minor cost (€1-5k)
  • 5-20 TB = egress becomes significant (€5-15k)
  • 20-100 TB = egress is major line item (€15-50k+), consider physical transfer
  • > 100 TB = egress dominates budget, physical transfer mandatory

Alternative Cost: Staying In Current State

Budget considerations should include cost of not migrating:

  • Ongoing MSP fees: Typical 15-25% annual increase over 5 years = 2-3x original cost
  • Vendor lock-in risk: Inability to negotiate = price acceptance (hard to quantify but real)
  • Compliance risk: Fines for data sovereignty violations can be €10M+ (low probability, extreme impact)
  • Opportunity cost: Inability to adopt new tech/providers because you're locked-in

For many organizations: €110-200k investment to break lock-in is cheaper than 5 years of 20% annual price increases on a €500k/year MSP contract (that becomes €1.24M in year 5).

Budget Reality Check

If your budget < €100k, you probably can't do a full sovereignty trajectory. Consider:

  • Phased approach: Do discovery + assessment (€53-82k), then decide if full migration worth it
  • Tactical improvements: Fix highest-risk gaps (identity cleanup, external access audit) without full migration
  • Contract optimization: Invest €15-30k in better contract terms instead of infrastructure changes

Budget Justification For Executives

Frame it as strategic infrastructure investment, not as "IT project":

  • Risk reduction: Eliminate single vendor dependency (quantify: what does 48h outage cost?)
  • Cost control: Break free from annual price increases (show 5-year TCO comparison)
  • Strategic optionality: Ability to adopt new tech/vendors without rip-and-replace (hard to quantify, strategically valuable)
  • Compliance: Meet data sovereignty requirements (avoid regulatory risk)

Pitch: "€150k investment now prevents €500k+ in excess costs over 5 years, while reducing strategic risk and increasing operational flexibility."

8. Provider-Specific Gotchas

Every cloud provider has its own quirks that complicate migration. Here are the concrete gotchas you need to know before you start, plus workarounds.

Azure

⚠️ Managed Identities Are Not Portable

Azure Managed Identities are fantastic for security (no credentials in code), but they're Azure-specific. If your applications build on these and you later want to migrate to AWS/GCP, you'll need complete authentication refactoring.

🔧 Workaround: Use managed identities for Azure-native services, but maintain abstraction layer for cross-cloud scenarios. Or: accept rework during migration.

📋 Before migration: Inventory which apps use managed identities. Budget 2-4 weeks per app for auth refactor.

⚠️ Private Endpoints Require VNet Redesign

If you use Private Endpoints (recommended for security), your resources are in VNets. Migration = VNet restructuring, which implies downtime for connected services.

🔧 Workaround: Plan VNet migration in batches. Test cutover scenarios in pilot. Consider temporary public endpoint exposure during transition (with strict IP whitelisting).

📋 Before migration: Document all private endpoint dependencies. Plan VNet migration as separate phase before workload migration.

⚠️ Azure AD Integration Is Deep

If you have Single Sign-On via Azure AD for cloud resources, that doesn't transfer to other clouds. You'll need to redesign identity federation.

🔧 Workaround: Implement identity provider abstraction (SAML/OIDC) that works against any IdP. Or: use third-party IdP (Okta, Auth0) that's cloud-agnostic.

📋 Before migration: Identity architecture redesign can take 2-3 months. Start this early.

AWS

⚠️ IAM Differences Are Subtle But Breaking

AWS IAM policies have subtle differences from Azure RBAC. "Reader" in Azure ≠ exact same as AWS equivalent. Permissions must be remapped.

🔧 Workaround: Build permission mapping matrix (Azure role → AWS equivalent). Test extensively — missing permissions lead to runtime failures.

📋 Before migration: IAM audit + remapping is 3-4 weeks work for complex environments.

⚠️ VPC Configuration Is More Complex Than Azure VNets

AWS VPCs have more configuration surface: route tables, NACLs, security groups, subnets. Migration from Azure VNet to AWS VPC isn't 1:1 mapping.

🔧 Workaround: Design AWS VPC architecture from scratch based on requirements, not as "translation" of Azure VNet.

📋 Before migration: Network redesign + testing = 4-6 weeks. Pilot network setup before you migrate workloads.

⚠️ RDS Backups Are Region-Locked

AWS RDS automated backups stay in the same region. Cross-region restore requires manual snapshot copy, which takes time for large databases.

🔧 Workaround: Pre-copy snapshots to target region before migration cutover. Or: use AWS DMS for live replication.

📋 Before migration: Plan extra time for snapshot propagation (can be hours to days for TB-scale databases).

⚠️ S3 Lifecycle Policies Must Be Redesigned

Azure Blob Storage lifecycle policies ≠ S3 lifecycle policies. Syntax different, capabilities different. Existing policies must be refactored.

🔧 Workaround: Document existing lifecycle behavior, redesign for S3, test extensively with small dataset before you migrate bulk data.

📋 Before migration: Lifecycle policy redesign + validation = 1-2 weeks per storage tier.

GCP

⚠️ Service Accounts Work Fundamentally Differently

GCP service accounts are full identities (with email addresses), not just credentials like Azure. This has implications for IAM design.

🔧 Workaround: Redesign authentication flows to accommodate GCP service account model. This isn't drop-in replacement.

📋 Before migration: Authentication architecture review + redesign = 3-4 weeks.

⚠️ VPC Peering Has Limitations

GCP VPC peering allows transitive connectivity, which has security implications that differ from Azure/AWS. Existing security assumptions must be reviewed.

🔧 Workaround: Redesign VPC architecture with GCP's transitive connectivity in mind. Use firewall rules aggressively to limit exposure.

📋 Before migration: Security review + VPC redesign = 2-3 weeks.

⚠️ Storage Classes Are Not Equivalent

GCP storage classes (Standard, Nearline, Coldline, Archive) have different cost/performance trade-offs than Azure (Hot/Cool/Archive). Data must be re-tiered.

🔧 Workaround: Analyze access patterns, map to GCP classes, test performance before bulk migration.

📋 Before migration: Storage tiering analysis + migration = 2-3 weeks depending on data volume.

⚠️ BigQuery Is Not Just A Database

If you use Azure Synapse or AWS Redshift and want to migrate to BigQuery: this isn't straightforward. Query syntax different, optimization patterns different.

🔧 Workaround: Budget significant refactor time. BigQuery is powerful but requires different mental model.

📋 Before migration: Analytics workload refactor can take 2-6 months depending on complexity.

Multi-Cloud Is Not "Best of Both Worlds"

Many organizations think: "We'll go multi-cloud, then we have flexibility!" Reality: multi-cloud = multi-complexity. You now have:

  • Two sets of IAM policies to maintain
  • Two network architectures to manage
  • Two security models to audit
  • Two cost structures to optimize
  • Two sets of expertise to maintain in your team

Multi-cloud makes sense only if: (1) You have capacity to run both, (2) Regulatory/sovereignty requirements force it, (3) You have specific workloads that genuinely fit better on specific clouds.

9. SAP on Azure: Concrete Scenario

SAP landscapes are complex, business-critical, and often fully managed by partners. Here's a realistic scenario of data sovereignty for a midsize SAP deployment.

What You're Dealing With

Typical SAP Landscape (mid-size org):

  • HANA Database: 8 TB production data (ERP transactional data)
  • Application Servers: 6 VMs (ECC, S/4HANA, BW)
  • Storage: 12 TB total (database + file shares + interfaces)
  • Backups: 20 TB (daily incrementals + weekly fulls, 4 weeks retention)
  • Interfaces: 15-20 external integrations (EDI, API, SFTP to partners/suppliers)

Management: Fully managed by SAP Basis partner. Internal team has functional knowledge (business processes), but no technical SAP Basis skills.

Before Extraction: Map This

Database Tier:

  • HANA primary instance (where is it, what VM size, what storage tier)
  • Backup strategy (which tool, where do backups go, retention policy)
  • Replication (is there DR setup? Where is the replica?)
  • Performance baseline (IOPS, latency, throughput requirements)

Application Tier:

  • All SAP modules deployed (ECC, BW, Fiori, Solution Manager)
  • Custom ABAP code (how many Z* programs, are these documented?)
  • Patches & support packs (which version, when last update)
  • Dependencies (which apps talk to SAP, how?)

Integration Tier:

  • Inbound interfaces (EDI, APIs, batch uploads — from whom, how often?)
  • Outbound interfaces (to which systems, real-time vs batch?)
  • Middleware (SAP PI/PO, integration platforms)
  • External partner access (who can directly log into SAP?)

Storage Tier:

  • File shares (transport directory, interface folders, archives)
  • Archive data (old fiscal years, compliance retention)
  • Development/QA environments (how are these synced with production?)

Reality Check: Partner Knowledge Is Critical

Your SAP Basis partner has knowledge that isn't documented: workarounds for specific performance issues, custom scripts for backups, undocumented integration patterns. Extracting this knowledge requires structured sessions — minimum 8-12 hours with senior partner architect.

Extraction Scenarios

Scenario 1: Full Cloud Extraction (Azure → On-Prem)

What: Complete SAP landscape move from Azure to on-premise datacenter.

Steps:

  • Phase 1 (2-3 months): Build on-prem capacity (hardware procurement, datacenter prep, network setup)
  • Phase 2 (1-2 months): Pilot migration with QA environment (test backup/restore, performance validation)
  • Phase 3 (2-3 weeks): Production cutover (backup, ship physical media, restore, cutover)
  • Phase 4 (1 month): Stabilization + old environment decom

Cost:

  • Hardware (servers, storage, network): €200-350k (CAPEX)
  • Egress via physical (Data Box): €300 shipping
  • Professional services (migration execution): €80-120k
  • Total: €280-470k + internal time

Timeline: 6-9 months total

Risk: High — hardware dependencies, datacenter readiness, physical logistics

Scenario 2: Cloud-to-Cloud (Azure → AWS/GCP)

What: Re-platform SAP to another cloud (vendor diversification).

Steps:

  • Phase 1 (2 months): Target architecture design (AWS/GCP equivalent sizing)
  • Phase 2 (6-8 weeks): Network setup (VPN, direct connect, peering)
  • Phase 3 (4-6 weeks): Pilot with QA (backup from Azure, restore to AWS/GCP, validate)
  • Phase 4 (2-3 weeks): Production cutover (parallel run possible, reduces risk)

Cost:

  • Egress from Azure: €2,150 (20 TB @ tiered pricing)
  • Target cloud infrastructure: €15-25k (parallel run duration)
  • Professional services: €60-100k
  • Total: €77-127k + internal time

Timeline: 5-7 months

Risk: Medium — cloud-to-cloud is easier than on-prem, but SAP-specific gotchas remain

Scenario 3: Hybrid (Keep Production, Extract Dev/QA)

What: Production stays in Azure (stability), but dev/QA environments to on-prem (cost reduction + control).

Steps:

  • Phase 1 (1-2 months): On-prem capacity for non-prod
  • Phase 2 (3-4 weeks): Migrate QA environment (test migration process)
  • Phase 3 (2-3 weeks): Migrate DEV environment
  • Phase 4 (ongoing): Maintain hybrid (Azure prod, on-prem non-prod)

Cost:

  • Hardware (smaller capacity, non-prod only): €80-120k
  • Egress (non-prod data, smaller volume): €200-500
  • Professional services: €30-50k
  • Total: €110-170k

Timeline: 3-5 months

Risk: Low-Medium — non-prod extraction is lower risk, prod remains stable

Comparison Matrix

Scenario Cost Timeline Risk Sovereignty Gain
Full On-Prem €280-470k 6-9 months High Maximum (complete control)
Cloud-to-Cloud €77-127k 5-7 months Medium Significant (vendor diversification)
Hybrid €110-170k 3-5 months Low-Medium Partial (control over non-prod)

Questions You Must Answer

  1. Downtime tolerance: Can you have SAP offline for 48-72 hours for cutover? (Most orgs: no)
  2. Parallel run capacity: Can we run old + new environment in parallel? (Doubles cost during transition)
  3. Interface cutover: How do external partners switch to new endpoints? (Coordination = time)
  4. Performance validation: How do we measure that new environment has equivalent performance?
  5. Rollback plan: If migration fails, how quickly can we go back? (Need old environment intact)
  6. Support continuity: Who supports SAP post-migration? (Partner stays, or build internal?)

SAP Is Not "Just Another Workload"

SAP migrations fail more often than other workloads because: (1) Business criticality = zero error tolerance, (2) Complexity is high (integrations, custom code, performance tuning), (3) Downtime is barely acceptable.

Success factor: Extensive pilot testing. Don't touch production until you've run QA migration 3x flawlessly.

10. The Hard Questions

Data sovereignty trajectories don't fail because of technology — they fail from lack of strategic commitment, insufficient capacity, or unrealistic expectations. Here are the questions you must answer before you start.

Strategic Commitment

Is this a board-level priority?

If data sovereignty isn't a strategic priority for executives, you won't get the budget, capacity, and political support needed. "IT wants this" is insufficient. "Board approved this as strategic initiative" is what you need.

Test: Can your CTO/CIO articulate this in board meeting? Is it in strategic plan for coming 2 years?

Is there budget for the full trajectory?

€110-200k+ is significant investment. Budget must not only be allocated but also protected — not the first thing cut during budget reviews.

Test: Is budget multi-year committed? Is there contingency reserve (20-30% buffer)?

Is there executive sponsorship?

You need a sponsor who can remove obstacles, force decisions, and has political capital to align stakeholders.

Test: Who is the sponsor? Do they have authority to make budget/people decisions?

Capacity Reality

Do we have people who can lead this?

Not execute — lead. This requires architectural judgment, program management skills, and political savvy. You need at least 1 person who can do all three.

Test: Who is the lead? Do they have track record with migrations of this scale? Can they work fulltime on this project?

Can we sustain 20-30% FTE commitment over 8-18 months?

This isn't "do it when you have time". It requires consistent capacity from core team (2-3 engineers + architect + PM).

Test: Are these people freed up from other responsibilities? Or is this "on top of" their normal work? (Latter = failure mode)

Are we willing to invest in capacity building?

If you have internal capacity, it must be maintained (training, certifications, tools). If you don't have it, it must be built (hiring, onboarding, learning curve).

Test: Is there training budget? Hiring plan if capacity is insufficient?

Risk Appetite

How much downtime is acceptable?

Be realistic. "Zero downtime" requires 3-5x the effort of "weekend downtime acceptable". Most organizations can tolerate some downtime for non-customer-facing systems.

Test: Per system: acceptable downtime window? (12 hours? 24 hours? 48 hours?)

Do we have a rollback plan?

If migration fails (it happens), how quickly can we return to old state? This requires old environment stays intact during transition — which has cost implications (dual infrastructure).

Test: How long do we keep old environment? (Typical: 1-3 months post-cutover)

Incremental vs. Big Bang?

Incremental migration (workload by workload) = lower risk, longer timeline. Big bang (everything at once) = faster but higher risk.

Test: What fits our risk tolerance? Our business constraints?

Alternative Assessment

Is complete sovereignty really the goal?

Maybe "ability to switch vendors" is sufficient. That doesn't require complete extraction — only architecture knowledge + contractual exit rights.

Test: What's the real problem? Vendor pricing? Compliance risk? Strategic optionality?

Can we solve this with better contracts?

€15-30k investment in contract renegotiation (exit clauses, knowledge transfer rights, price protection) often solves the same problem without infrastructure changes.

Test: Have we tried contract renegotiation? What was response?

Is hybrid sovereignty an acceptable outcome?

Not everything needs to be on-prem or self-managed. Hybrid (critical systems self-managed, rest stays outsourced) is often realistic balance between sovereignty and operational burden.

Test: Which 20% of workloads gives 80% sovereignty gain?

Go/No-Go Framework

Decision Checklist

GO if:

  • ✅ Board-level commitment + protected budget
  • ✅ Lead person identified + capacity allocated
  • ✅ Realistic timeline (8-18 months) accepted
  • ✅ Risk appetite matches approach
  • ✅ Architecture knowledge recovery is complete (Phase 1-3 done)

NO-GO if:

  • ❌ Budget < €100k or not committed
  • ❌ No lead person with capacity
  • ❌ Downtime tolerance = zero but no budget for zero-downtime approach
  • ❌ "We'll figure it out as we go" planning
  • ❌ Architecture knowledge still incomplete

PAUSE if:

  • ⏸️ Commitment exists but capacity must still be built
  • ⏸️ Budget allocated but timeline too ambitious
  • ⏸️ Architecture knowledge recovery ongoing (wait for Phase 3 completion)

Final Reality Check: It's ok to conclude NO-GO. Better to acknowledge "this doesn't fit our current strategic priorities/capacity" than to start a half-baked trajectory that fails and damages credibility.

11. Execution Framework

If you've been through all hard questions and made GO decision, here's how to structure execution for success.

Phase Structure With Gates

Use formal phase gates to validate progress and force go/no-go decisions per phase:

Gate 1 (After Discovery):

  • ✓ Complete architecture inventory available
  • ✓ External access registry complete
  • ✓ Identity audit done + risk classification
  • ✓ Dependency mapping validated
  • Decision: Proceed to Assessment or STOP (gaps too large)

Gate 2 (After Assessment):

  • ✓ STM Scorecard complete (sovereignty baseline known)
  • ✓ Cost-benefit analysis done (ROI acceptable?)
  • ✓ Capacity assessment done (can we do this?)
  • ✓ Risk assessment + mitigation plan
  • Decision: Proceed to Planning or STOP (ROI insufficient / risk too high)

Gate 3 (After Planning):

  • ✓ Target architecture designed + validated
  • ✓ Migration roadmap approved
  • ✓ Identity cleanup complete
  • ✓ Budget finalized + committed
  • ✓ Team allocated + trained
  • Decision: Proceed to Pilot or PAUSE (capacity/budget not ready)

Gate 4 (After Pilot):

  • ✓ Pilot migration successful (workloads running stable)
  • ✓ Performance validated (meets requirements)
  • ✓ Cost validated (matches estimates)
  • ✓ Runbooks tested + documented
  • ✓ Team capable (proven in pilot)
  • Decision: Proceed to Production Migration or STOP (pilot revealed blockers)

Team Roles

Executive Sponsor

  • Authority: Budget approval, strategic decisions, stakeholder escalation
  • Time commitment: 2-4 hours/month (steering meetings + escalations)
  • Key responsibilities: Remove obstacles, protect budget, maintain board alignment

Program Lead

  • Authority: Tactical decisions, resource allocation, vendor management
  • Time commitment: 100% dedicated (fulltime role for trajectory duration)
  • Key responsibilities: Overall delivery, risk management, stakeholder coordination

Architect

  • Authority: Technical decisions, design validation, standards enforcement
  • Time commitment: 50-75% (spikes to 100% during design phases)
  • Key responsibilities: Architecture design, technical risk assessment, engineering guidance

Engineering Team (2-4 engineers)

  • Authority: Implementation decisions within architectural constraints
  • Time commitment: 30-50% sustained (spikes to 100% during migration phases)
  • Key responsibilities: Hands-on migration execution, testing, troubleshooting

Stakeholder Representatives

  • From: Business units, IT ops, security, compliance
  • Time commitment: 5-10% (requirements, validation, approval)
  • Key responsibilities: Provide domain expertise, validate outcomes, approve go-live

Risk Management

Maintain Risk Register:

  • Document risks weekly (technical, schedule, budget, stakeholder)
  • Classify: Likelihood (low/med/high) × Impact (low/med/high)
  • High risks (high likelihood + high impact): escalate immediately
  • Mitigation plans for all medium+ risks

Common Risk Patterns:

  • Discovered dependencies: System A depends on System B, undocumented. Mitigation: Extended discovery, incremental testing.
  • Key person departure: Lead engineer leaves during trajectory. Mitigation: Knowledge documentation, overlap during onboarding.
  • Vendor non-cooperation: Current MSP doesn't help with knowledge transfer. Mitigation: Contractual escalation, shadow documentation.
  • Scope creep: "While we're at it, let's also..." Mitigation: Formal change control, scope freeze after planning phase.

Success Criteria

Technical Success:

  • All workloads running stable in target environment (> 99.5% uptime first month)
  • Performance meets or exceeds baseline (validated with production load)
  • Cost within 10% of estimate (excluding unpredictable egress)
  • Zero critical security vulnerabilities introduced

Operational Success:

  • Internal team can operate new environment without daily partner support
  • Documentation is complete + validated
  • Runbooks tested + proven (incident response < baseline MTTR)
  • Monitoring + alerting operational

Strategic Success:

  • Sovereignty score improved (re-run STM scorecard post-migration)
  • Vendor dependency reduced (measured via contract leverage)
  • Organization can now evaluate alternative providers without fear

Celebrate Milestones

Trajectories of 8-18 months are marathons, not sprints. Celebrate gates:

  • ✓ Gate 1 passed: "We know what we have"
  • ✓ Gate 3 passed: "We have a plan"
  • ✓ Pilot success: "We proved we can do this"
  • ✓ First production workload migrated: "We're doing it"
  • ✓ Final decom: "We're independent"

Team morale matters. Recognize progress.

Closing: What Now?

You now have a realistic picture of what data sovereignty requires: 8-18 months, €110-200k+, significant capacity investment, and strategic commitment. This isn't "just migrating" — this is fundamental transformation of how you manage infrastructure.

If You're Ready

Start with Discovery (Phase 1):

  • Allocate 2-3 engineers for 6-12 weeks
  • Deploy automated discovery tools
  • Schedule knowledge extraction sessions with current MSP
  • Run external access + identity audits
  • Budget: €30-45k

After Discovery you have: complete architecture inventory, gap analysis, and realistic effort estimate. Then you can make informed GO/NO-GO decision.

Parallel: Run STM Scorecard

While Discovery runs, take the STM Sovereignty Scorecard. This gives you baseline score + gap prioritization. Use this to focus Discovery on highest-risk areas.

If You're Not Ready

That's ok. Better to acknowledge "this doesn't fit our current situation" than a failed trajectory.

Tactical Improvements (Without Full Migration):

  • Identity cleanup: €8-15k investment, 4-6 weeks. Reduces security risk + improves sovereignty posture without migration.
  • External access audit: €5-10k, 2-3 weeks. Visibility = first step toward control.
  • Contract renegotiation: €15-30k legal/consulting support. Better exit clauses + knowledge transfer rights = practical sovereignty improvement.
  • STM quarterly assessment: Track sovereignty score over time. Identify degradation early.

Build Capacity First:

If your internal capacity is insufficient, invest in building it before you start migration:

  • Hire cloud architect (6-12 months contract)
  • Train existing team (certifications, hands-on projects)
  • Pilot with non-critical workload (learn without risk)
  • Re-assess in 12 months

S23k Position

We document what sovereignty really requires — not because we want to sell it as a product, but because industry needs realistic expectations. Too many trajectories fail because organizations underestimate the complexity, underbudget the effort, or overestimate their internal capacity.

Data sovereignty is achievable — but it's not easy. It requires strategic commitment, significant investment, and sustained capacity. Organizations that understand this and plan accordingly, succeed. Organizations that underestimate this, fail and have damaged credibility.

This playbook gives you what you need to make an informed decision. Whether that's GO, NO-GO, or PAUSE — that's up to you. But at least now you know what it really takes.

Next Steps

Assess your current posture:
Take the STM Sovereignty Scorecard →

Understand the principles:
Read the ZAA Doctrine →

Questions? Contact S23k
We don't sell sovereignty-as-a-service. We help you understand what it takes, then you decide.