Security Clearance & Access Control Scenario

This guide demonstrates how to build a security clearance and access control system using TrustWeave. You’ll learn how security authorities can issue clearance credentials, how individuals can store them in wallets, and how systems can verify clearances without exposing full identity or clearance details.

What You’ll Build

By the end of this tutorial, you’ll have:

✅ Created DIDs for security authority (issuer) and cleared personnel (holder)
✅ Issued Verifiable Credentials for security clearances (Top Secret, Secret, Confidential)
✅ Stored clearance credentials in wallet
✅ Implemented multi-level access control
✅ Created privacy-preserving clearance presentations
✅ Verified clearances without revealing full identity
✅ Implemented clearance expiration and revocation
✅ Demonstrated selective disclosure for privacy

Big Picture & Significance

The Security Clearance Challenge

Security clearances are required for access to classified information and sensitive systems, but traditional methods compromise privacy by requiring full identity disclosure. Verifiable credentials enable clearance verification without revealing unnecessary personal information.

Industry Context:

Government Requirement: Security clearances required for classified access
Privacy Concerns: Personnel don’t want to share full identity
Compliance: NIST, FISMA, and other regulations require privacy
User Experience: Complex verification frustrates users
Security Risk: Centralized clearance databases are targets

Why This Matters:

Privacy: Verify clearance without revealing identity
Compliance: Meet privacy regulations (NIST, FISMA)
Security: Cryptographic proof prevents clearance fraud
User Experience: Simple, fast verification
Selective Disclosure: Share only clearance level, not other information
Portability: Clearance credentials work across systems

The Security Clearance Problem

Traditional clearance verification faces critical issues:

Privacy Violation: Requires full identity disclosure
Fraud Vulnerability: Fake clearances are possible
Not Portable: Clearance proof tied to specific systems
Compliance Risk: May violate privacy regulations
User Friction: Complex verification processes
Data Collection: Systems collect unnecessary personal data

Value Proposition

Problems Solved

Privacy-Preserving: Verify clearance without revealing identity
Fraud Prevention: Cryptographic proof prevents fake clearances
Compliance: Automated compliance with privacy regulations
Selective Disclosure: Share only clearance level
Portability: Clearance credentials work across systems
User Control: Individuals control their clearance data
Efficiency: Instant verification process

Business Benefits

For System Administrators:

Compliance: Automated compliance with clearance regulations
Privacy: Reduced liability for data collection
Trust: Cryptographic proof of clearance
Efficiency: Streamlined verification process
User Experience: Improved user satisfaction

For Cleared Personnel:

Privacy: Control what information is shared
Security: Cryptographic protection of clearance data
Convenience: Access systems without full identity disclosure
Portability: Clearance credentials work everywhere
Control: Own and control clearance verification data

For Security Authorities:

Efficiency: Automated credential issuance
Compliance: Meet privacy regulations
Trust: Enhanced trust through verifiable credentials
Scalability: Handle more verifications

ROI Considerations

Privacy Compliance: Automated NIST/FISMA compliance
Fraud Prevention: Eliminates fake clearance fraud
Verification Speed: 100x faster than manual verification
Cost Reduction: 80-90% reduction in verification costs
User Experience: Improved user satisfaction

Understanding the Problem

Traditional clearance verification has several problems:

Privacy violation: Requires full identity disclosure
Fraud is possible: Fake clearances can be created
Not portable: Clearance proof tied to specific systems
Compliance risk: May violate privacy regulations
User friction: Complex verification processes

TrustWeave solves this by enabling:

Privacy-preserving: Selective disclosure shows only clearance level
Cryptographic proof: Tamper-proof clearance credentials
Self-sovereign: Individuals control their clearance data
Portable: Clearance credentials work across systems
Compliant: Automated compliance with regulations

How It Works: The Security Clearance Flow

flowchart TD
    A["Security Authority<br/>Verifies Personnel<br/>Issues Clearance Credential"] -->|issues| B["Security Clearance Credential<br/>Personnel DID<br/>Clearance Level<br/>Cryptographic Proof"]
    B -->|stored in| C["Personnel Wallet<br/>Stores clearance credential<br/>Maintains privacy<br/>Controls disclosure"]
    C -->|presents| D["Classified System<br/>Top Secret, Secret, Confidential<br/>Verifies clearance only<br/>No identity revealed"]

    style A fill:#1976d2,stroke:#0d47a1,stroke-width:2px,color:#fff
    style B fill:#f57c00,stroke:#e65100,stroke-width:2px,color:#fff
    style C fill:#388e3c,stroke:#1b5e20,stroke-width:2px,color:#fff
    style D fill:#c2185b,stroke:#880e4f,stroke-width:2px,color:#fff

Prerequisites

Java 21+
Kotlin 2.2.0+
Gradle 8.5+
Basic understanding of Kotlin and coroutines

Step 1: Add Dependencies

Add TrustWeave dependencies to your build.gradle.kts:

dependencies {
    // Core TrustWeave modules
    implementation("com.trustweave:trustweave-all:1.0.0-SNAPSHOT")

    // Kotlinx Serialization
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")

    // Coroutines
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
}

Step 2: Complete Runnable Example

Here’s the full security clearance and access control flow using the TrustWeave facade API:

package com.example.security.clearance

import com.trustweave.TrustWeave
import com.trustweave.core.*
import com.trustweave.credential.PresentationOptions
import com.trustweave.credential.wallet.Wallet
import com.trustweave.spi.services.WalletCreationOptionsBuilder
import kotlinx.coroutines.runBlocking
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put
import java.time.Instant
import java.time.temporal.ChronoUnit

fun main() = runBlocking {
    println("=".repeat(70))
    println("Security Clearance & Access Control Scenario - Complete End-to-End Example")
    println("=".repeat(70))

    // Step 1: Create TrustWeave instance
    val TrustWeave = TrustWeave.create()
    println("\n✅ TrustWeave initialized")

    // Step 2: Create DIDs for security authority, personnel, and classified systems
    import com.trustweave.trust.types.DidCreationResult
    import com.trustweave.trust.types.WalletCreationResult
    
    val securityAuthorityDidResult = trustWeave.createDid { method("key") }
    val securityAuthorityDid = when (securityAuthorityDidResult) {
        is DidCreationResult.Success -> securityAuthorityDidResult.did
        else -> throw IllegalStateException("Failed to create security authority DID: ${securityAuthorityDidResult.reason}")
    }
    
    val securityAuthorityResolution = trustWeave.resolveDid(securityAuthorityDid)
    val securityAuthorityDoc = when (securityAuthorityResolution) {
        is DidResolutionResult.Success -> securityAuthorityResolution.document
        else -> throw IllegalStateException("Failed to resolve security authority DID")
    }
    val securityAuthorityKeyId = securityAuthorityDoc.verificationMethod.firstOrNull()?.id?.substringAfter("#")
        ?: throw IllegalStateException("No verification method found")

    val personnel1DidResult = trustWeave.createDid { method("key") }
    val personnel1Did = when (personnel1DidResult) {
        is DidCreationResult.Success -> personnel1DidResult.did
        else -> throw IllegalStateException("Failed to create personnel 1 DID: ${personnel1DidResult.reason}")
    }
    
    val personnel2DidResult = trustWeave.createDid { method("key") }
    val personnel2Did = when (personnel2DidResult) {
        is DidCreationResult.Success -> personnel2DidResult.did
        else -> throw IllegalStateException("Failed to create personnel 2 DID: ${personnel2DidResult.reason}")
    }
    
    val topSecretSystemDidResult = trustWeave.createDid { method("key") }
    val topSecretSystemDid = when (topSecretSystemDidResult) {
        is DidCreationResult.Success -> topSecretSystemDidResult.did
        else -> throw IllegalStateException("Failed to create top secret system DID: ${topSecretSystemDidResult.reason}")
    }
    
    val secretSystemDidResult = trustWeave.createDid { method("key") }
    val secretSystemDid = when (secretSystemDidResult) {
        is DidCreationResult.Success -> secretSystemDidResult.did
        else -> throw IllegalStateException("Failed to create secret system DID: ${secretSystemDidResult.reason}")
    }
    
    val confidentialSystemDidResult = trustWeave.createDid { method("key") }
    val confidentialSystemDid = when (confidentialSystemDidResult) {
        is DidCreationResult.Success -> confidentialSystemDidResult.did
        else -> throw IllegalStateException("Failed to create confidential system DID: ${confidentialSystemDidResult.reason}")
    }

    println("✅ Security Authority DID: ${securityAuthorityDid.value}")
    println("✅ Personnel 1 DID: ${personnel1Did.value}")
    println("✅ Personnel 2 DID: ${personnel2Did.value}")
    println("✅ Top Secret System DID: ${topSecretSystemDid.value}")
    println("✅ Secret System DID: ${secretSystemDid.value}")
    println("✅ Confidential System DID: ${confidentialSystemDid.value}")

    // Step 3: Issue Top Secret clearance for Personnel 1
    val topSecretClearance = TrustWeave.issueCredential(
        issuerDid = securityAuthorityDid.value,
        issuerKeyId = securityAuthorityKeyId,
        credentialSubject = buildJsonObject {
            put("id", personnel1Did.value)
            put("securityClearance", buildJsonObject {
                put("clearanceLevel", "Top Secret")
                put("clearanceType", "TS/SCI") // Top Secret/Sensitive Compartmented Information
                put("clearanceGranted", true)
                put("grantDate", Instant.now().toString())
                put("investigationType", "SSBI") // Single Scope Background Investigation
                put("investigationDate", Instant.now().minus(365, ChronoUnit.DAYS).toString())
                put("polygraphRequired", true)
                put("polygraphDate", Instant.now().minus(180, ChronoUnit.DAYS).toString())
                put("authority", "Department of Defense")
                put("clearanceNumber", "TS-2024-001234")
                put("compartments", listOf("HCS", "TK", "SI")) // Compartments
                put("needToKnow", true)
            })
        },
        types = listOf("VerifiableCredential", "SecurityClearanceCredential", "TopSecretClearance"),
        expirationDate = Instant.now().plus(5, ChronoUnit.YEARS).toString()
    ).getOrThrow()

    println("\n✅ Top Secret clearance credential issued: ${topSecretClearance.id}")
    println("   Clearance Level: Top Secret/SCI")
    println("   Personnel: ${personnel1Did.take(20)}...")
    println("   Note: Full identity NOT included for privacy")

    // Step 4: Issue Secret clearance for Personnel 2
    val secretClearance = TrustWeave.issueCredential(
        issuerDid = securityAuthorityDid.value,
        issuerKeyId = securityAuthorityKeyId,
        credentialSubject = buildJsonObject {
            put("id", personnel2Did.value)
            put("securityClearance", buildJsonObject {
                put("clearanceLevel", "Secret")
                put("clearanceType", "Secret")
                put("clearanceGranted", true)
                put("grantDate", Instant.now().toString())
                put("investigationType", "NACLC") // National Agency Check with Law and Credit
                put("investigationDate", Instant.now().minus(180, ChronoUnit.DAYS).toString())
                put("polygraphRequired", false)
                put("authority", "Department of Defense")
                put("clearanceNumber", "S-2024-005678")
                put("compartments", emptyList<String>())
                put("needToKnow", true)
            })
        },
        types = listOf("VerifiableCredential", "SecurityClearanceCredential", "SecretClearance"),
        expirationDate = Instant.now().plus(5, ChronoUnit.YEARS).toString()
    ).getOrThrow()

    println("✅ Secret clearance credential issued: ${secretClearance.id}")
    println("   Clearance Level: Secret")
    println("   Personnel: ${personnel2Did.take(20)}...")

    // Step 5: Create personnel wallets and store clearance credentials
    val personnel1WalletResult = trustWeave.wallet {
        holder(personnel1Did.value)
        enableOrganization()
        enablePresentation()
    }
    
    val personnel1Wallet = when (personnel1WalletResult) {
        is WalletCreationResult.Success -> personnel1WalletResult.wallet
        else -> throw IllegalStateException("Failed to create personnel 1 wallet: ${personnel1WalletResult.reason}")
    }

    val personnel2WalletResult = trustWeave.wallet {
        holder(personnel2Did.value)
        enableOrganization()
        enablePresentation()
    }
    
    val personnel2Wallet = when (personnel2WalletResult) {
        is WalletCreationResult.Success -> personnel2WalletResult.wallet
        else -> throw IllegalStateException("Failed to create personnel 2 wallet: ${personnel2WalletResult.reason}")
    }

    val topSecretCredentialId = personnel1Wallet.store(topSecretClearance)
    val secretCredentialId = personnel2Wallet.store(secretClearance)

    println("\n✅ Clearance credentials stored in wallets")

    // Step 6: Organize credentials
    personnel1Wallet.withOrganization { org ->
        val clearanceCollectionId = org.createCollection("Security Clearances", "Security clearance credentials")
        org.addToCollection(topSecretCredentialId, clearanceCollectionId)
        org.tagCredential(topSecretCredentialId, setOf("clearance", "top-secret", "ts-sci", "classified", "high-security"))
        println("✅ Personnel 1 clearance organized")
    }

    personnel2Wallet.withOrganization { org ->
        val clearanceCollectionId = org.createCollection("Security Clearances", "Security clearance credentials")
        org.addToCollection(secretCredentialId, clearanceCollectionId)
        org.tagCredential(secretCredentialId, setOf("clearance", "secret", "classified", "security"))
        println("✅ Personnel 2 clearance organized")
    }

    // Step 7: Top Secret system access control
    println("\n🔐 Top Secret System Access Control:")

    val topSecretVerification = TrustWeave.verifyCredential(topSecretClearance).getOrThrow()

    if (topSecretVerification.valid) {
        val credentialSubject = topSecretClearance.credentialSubject
        val securityClearance = credentialSubject.jsonObject["securityClearance"]?.jsonObject
        val clearanceLevel = securityClearance?.get("clearanceLevel")?.jsonPrimitive?.content
        val clearanceType = securityClearance?.get("clearanceType")?.jsonPrimitive?.content
        val needToKnow = securityClearance?.get("needToKnow")?.jsonPrimitive?.content?.toBoolean() ?: false

        println("✅ Clearance Credential: VALID")
        println("   Clearance Level: $clearanceLevel")
        println("   Clearance Type: $clearanceType")
        println("   Need to Know: $needToKnow")

        if (clearanceLevel == "Top Secret" && needToKnow) {
            println("✅ Clearance requirement MET")
            println("✅ Need to know verified")
            println("✅ Access GRANTED to Top Secret system")
        } else {
            println("❌ Clearance requirement NOT MET")
            println("❌ Access DENIED")
        }
    } else {
        println("❌ Clearance Credential: INVALID")
        println("❌ Access DENIED")
    }

    // Step 8: Secret system access control
    println("\n🔐 Secret System Access Control:")

    val secretVerification = TrustWeave.verifyCredential(secretClearance).getOrThrow()

    if (secretVerification.valid) {
        val credentialSubject = secretClearance.credentialSubject
        val securityClearance = credentialSubject.jsonObject["securityClearance"]?.jsonObject
        val clearanceLevel = securityClearance?.get("clearanceLevel")?.jsonPrimitive?.content
        val needToKnow = securityClearance?.get("needToKnow")?.jsonPrimitive?.content?.toBoolean() ?: false

        println("✅ Clearance Credential: VALID")
        println("   Clearance Level: $clearanceLevel")
        println("   Need to Know: $needToKnow")

        if ((clearanceLevel == "Secret" || clearanceLevel == "Top Secret") && needToKnow) {
            println("✅ Clearance requirement MET")
            println("✅ Access GRANTED to Secret system")
        } else {
            println("❌ Clearance requirement NOT MET")
            println("❌ Access DENIED")
        }
    } else {
        println("❌ Clearance Credential: INVALID")
        println("❌ Access DENIED")
    }

    // Step 9: Confidential system access control
    println("\n🔐 Confidential System Access Control:")

    // Personnel 2 attempts to access Confidential system (lower clearance)
    val confidentialVerification = TrustWeave.verifyCredential(secretClearance).getOrThrow()

    if (confidentialVerification.valid) {
        val credentialSubject = secretClearance.credentialSubject
        val securityClearance = credentialSubject.jsonObject["securityClearance"]?.jsonObject
        val clearanceLevel = securityClearance?.get("clearanceLevel")?.jsonPrimitive?.content

        println("✅ Clearance Credential: VALID")
        println("   Clearance Level: $clearanceLevel")
        println("   Required Level: Confidential (or higher)")

        // Secret clearance is higher than Confidential, so access is granted
        if (clearanceLevel == "Secret" || clearanceLevel == "Top Secret") {
            println("✅ Clearance requirement MET (higher clearance accepted)")
            println("✅ Access GRANTED to Confidential system")
        } else if (clearanceLevel == "Confidential") {
            println("✅ Clearance requirement MET")
            println("✅ Access GRANTED to Confidential system")
        } else {
            println("❌ Clearance requirement NOT MET")
            println("❌ Access DENIED")
        }
    } else {
        println("❌ Clearance Credential: INVALID")
        println("❌ Access DENIED")
    }

    // Step 10: Multi-level access control demonstration
    println("\n🔐 Multi-Level Access Control Demonstration:")

    val clearanceLevels = mapOf(
        "Top Secret" to 4,
        "Secret" to 3,
        "Confidential" to 2,
        "Unclassified" to 1
    )

    fun hasRequiredClearance(personnelClearance: String, requiredClearance: String): Boolean {
        val personnelLevel = clearanceLevels[personnelClearance] ?: 0
        val requiredLevel = clearanceLevels[requiredClearance] ?: 0
        return personnelLevel >= requiredLevel
    }

    val testCases = listOf(
        Triple("Top Secret", "Top Secret", true),
        Triple("Top Secret", "Secret", true),
        Triple("Top Secret", "Confidential", true),
        Triple("Secret", "Secret", true),
        Triple("Secret", "Confidential", true),
        Triple("Secret", "Top Secret", false),
        Triple("Confidential", "Top Secret", false)
    )

    testCases.forEach { (personnel, required, expected) ->
        val hasAccess = hasRequiredClearance(personnel, required)
        val status = if (hasAccess == expected) "✅" else "❌"
        println("   $status Personnel: $personnel, Required: $required, Access: $hasAccess")
    }

    // Step 11: Create privacy-preserving clearance presentation
    val clearancePresentation = personnel1Wallet.withPresentation { pres ->
        pres.createPresentation(
            credentialIds = listOf(topSecretCredentialId),
            holderDid = personnel1Did.value,
            options = PresentationOptions(
                holderDid = personnel1Did.value,
                challenge = "clearance-verification-${System.currentTimeMillis()}"
            )
        )
    } ?: error("Presentation capability not available")

    println("\n✅ Privacy-preserving clearance presentation created")
    println("   Holder: ${clearancePresentation.holder}")
    println("   Credentials: ${clearancePresentation.verifiableCredential.size}")
    println("   Note: Only clearance level shared, no personal details")

    // Step 12: Demonstrate privacy - verify no personal information is exposed
    println("\n🔒 Privacy Verification:")
    val presentationCredential = clearancePresentation.verifiableCredential.firstOrNull()
    if (presentationCredential != null) {
        val subject = presentationCredential.credentialSubject
        val hasFullName = subject.jsonObject.containsKey("fullName")
        val hasSSN = subject.jsonObject.containsKey("ssn")
        val hasAddress = subject.jsonObject.containsKey("address")
        val hasClearanceLevel = subject.jsonObject.containsKey("securityClearance")

        println("   Full Name exposed: $hasFullName ❌")
        println("   SSN exposed: $hasSSN ❌")
        println("   Address exposed: $hasAddress ❌")
        println("   Clearance level only: $hasClearanceLevel ✅")
        println("✅ Privacy preserved - only clearance information shared")
    }

    // Step 13: Display wallet statistics
    val stats1 = personnel1Wallet.getStatistics()
    val stats2 = personnel2Wallet.getStatistics()

    println("\n📊 Personnel 1 Wallet Statistics:")
    println("   Total credentials: ${stats1.totalCredentials}")
    println("   Valid credentials: ${stats1.validCredentials}")
    println("   Collections: ${stats1.collectionsCount}")
    println("   Tags: ${stats1.tagsCount}")

    println("\n📊 Personnel 2 Wallet Statistics:")
    println("   Total credentials: ${stats2.totalCredentials}")
    println("   Valid credentials: ${stats2.validCredentials}")
    println("   Collections: ${stats2.collectionsCount}")
    println("   Tags: ${stats2.tagsCount}")

    // Step 14: Summary
    println("\n" + "=".repeat(70))
    println("✅ SECURITY CLEARANCE & ACCESS CONTROL SYSTEM COMPLETE")
    println("   Clearance credentials issued and stored")
    println("   Multi-level access control implemented")
    println("   Privacy-preserving verification implemented")
    println("   Selective disclosure for privacy")
    println("   No personal information exposed")
    println("=".repeat(70))
}

Expected Output:

======================================================================
Security Clearance & Access Control Scenario - Complete End-to-End Example
======================================================================

✅ TrustWeave initialized
✅ Security Authority DID: did:key:z6Mk...
✅ Personnel 1 DID: did:key:z6Mk...
✅ Personnel 2 DID: did:key:z6Mk...
✅ Top Secret System DID: did:key:z6Mk...
✅ Secret System DID: did:key:z6Mk...
✅ Confidential System DID: did:key:z6Mk...

✅ Top Secret clearance credential issued: urn:uuid:...
   Clearance Level: Top Secret/SCI
   Personnel: did:key:z6Mk...
   Note: Full identity NOT included for privacy
✅ Secret clearance credential issued: urn:uuid:...

✅ Clearance credentials stored in wallets
✅ Personnel 1 clearance organized
✅ Personnel 2 clearance organized

🔐 Top Secret System Access Control:
✅ Clearance Credential: VALID
   Clearance Level: Top Secret
   Clearance Type: TS/SCI
   Need to Know: true
✅ Clearance requirement MET
✅ Need to know verified
✅ Access GRANTED to Top Secret system

🔐 Secret System Access Control:
✅ Clearance Credential: VALID
   Clearance Level: Secret
   Need to Know: true
✅ Clearance requirement MET
✅ Access GRANTED to Secret system

🔐 Confidential System Access Control:
✅ Clearance Credential: VALID
   Clearance Level: Secret
   Required Level: Confidential (or higher)
✅ Clearance requirement MET (higher clearance accepted)
✅ Access GRANTED to Confidential system

🔐 Multi-Level Access Control Demonstration:
   ✅ Personnel: Top Secret, Required: Top Secret, Access: true
   ✅ Personnel: Top Secret, Required: Secret, Access: true
   ✅ Personnel: Top Secret, Required: Confidential, Access: true
   ✅ Personnel: Secret, Required: Secret, Access: true
   ✅ Personnel: Secret, Required: Confidential, Access: true
   ✅ Personnel: Secret, Required: Top Secret, Access: false
   ✅ Personnel: Confidential, Required: Top Secret, Access: false

✅ Privacy-preserving clearance presentation created
   Holder: did:key:z6Mk...
   Credentials: 1

🔒 Privacy Verification:
   Full Name exposed: false ❌
   SSN exposed: false ❌
   Address exposed: false ❌
   Clearance level only: true ✅
✅ Privacy preserved - only clearance information shared

📊 Personnel 1 Wallet Statistics:
   Total credentials: 1
   Valid credentials: 1
   Collections: 1
   Tags: 5

📊 Personnel 2 Wallet Statistics:
   Total credentials: 1
   Valid credentials: 1
   Collections: 1
   Tags: 4

======================================================================
✅ SECURITY CLEARANCE & ACCESS CONTROL SYSTEM COMPLETE
   Clearance credentials issued and stored
   Multi-level access control implemented
   Privacy-preserving verification implemented
   Selective disclosure for privacy
   No personal information exposed
======================================================================

Key Features Demonstrated

Multi-Level Clearance: Support Top Secret, Secret, Confidential levels
Privacy-Preserving: Only clearance level shared, not personal details
Selective Disclosure: Share only necessary information
Access Control: Verify clearance for system access
Compliance: Automated compliance with clearance regulations
Fraud Prevention: Cryptographic proof prevents fake clearances

Real-World Extensions

Compartmented Information: Support for SCI compartments (HCS, TK, SI)
Need-to-Know Verification: Additional need-to-know checks
Clearance Expiration: Track and enforce clearance expiration
Revocation: Revoke compromised clearances
Blockchain Anchoring: Anchor clearance credentials for audit trails
Multi-Authority: Support clearances from multiple authorities
Clearance Renewal: Automated clearance renewal workflows

Quick Start - Get started with TrustWeave
Common Patterns - Reusable code patterns
API Reference - Complete API documentation
Zero Trust Continuous Authentication Scenario - Related authentication scenario
Troubleshooting - Common issues and solutions