Overholdelse af kodeks i pipelines

Overholdelse af regler: Integrering af regulatoriske kontroller i rørledninger

En compliance-revision plejede at betyde en uge med hektisk indsamling af bevismateriale: skærmbilleder af konfigurationskonsoller, eksport af regnearksbilleder af adgangslogfiler og skrivning af fortællinger omkring kontroller, der aldrig var designet til at producere maskinlæsbart bevismateriale. Aftenen før revisoren ankom, var der altid nogen, der afstemte en uoverensstemmelse mellem, hvad politikdokumentet sagde, der skulle ske, og hvad systemloggene viste, der rent faktisk skete. Forskellen mellem de to, mellem den tilsigtede compliance-position og den demonstrerede compliance-position, var revisionsrisikoen, og den blev målt i timers manuel afstemning snarere end i sekunders automatiseret verifikation.

Kun 46 % af CISO'er er begyndt at implementere compliance som kode. Hvis du er blandt de resterende 54 %, er denne artikel din køreplan for at indhente det forsømte. Compliance-as-code konverterer den ugentlige brandøvelse til en kontinuerlig automatiseret proces: Enhver ændring af kode, konfiguration eller infrastruktur passerer gennem compliance-gates, før den når produktion, og hver gate producerer struktureret dokumentation, der er øjeblikkeligt tilgængelig for revisorer uden manuel indsamling. Den organisatoriske fordel rækker ud over revisionsberedskab. Integrering af compliance-kontroller i pipelines betyder, at compliance-problemer opdages, når de er billigst at løse, under udvikling, snarere end når de er dyrest, efter en lovgivningsmæssig konstatering eller en produktionshændelse.

For organisationer med moderne cloud-native applikationer er værktøjerne til compliance-as-code modne og veldokumenterede. For organisationer, hvis mest compliance-følsomme arbejdsbelastninger kører på COBOL-mainframes, som beskriver de fleste større banker, forsikringsselskaber og offentlige myndigheder, er udfordringen væsentligt mere kompleks, end standard compliance-as-code-håndbogen adresserer.

Revisionsspor for ældre kampagner

SMART TS XL verificerer, at programmer, der implementerer regulerede beregninger, forbliver strukturelt i overensstemmelse med den godkendte specifikation.

FÅ MERE AT VIDE…

Hvad compliance-as-code betyder, og hvad det ikke er

Overholdelse som kode er praksissen med at udtrykke overholdelseskrav som eksekverbar kode, maskinlæsbare politikker, regler og tests, der kører automatisk som en del af softwareleveringsprocessen. Overholdelseskontrollen er ikke et manuelt trin udført af en menneskelig korrekturlæser før implementering; det er en automatiseret gate, der kører uden menneskelig indgriben, producerer et bestået/ikke bestået resultat og genererer struktureret dokumentation for kontrollen.

I stedet for manuelle regneark, der går i stykker, hvis du kigger forkert på dem, og reaktive revisioner, der sker, efter at problemer opstår, får du automatiserede compliance-kontroller indbygget direkte i din CI/CD-pipeline. Din kode testes for compliance på samme måde, som den testes for fejl: kontinuerligt, automatisk og før den overhovedet når produktion.

Hvad compliance-as-code ikke er: Det er ikke en dokumentationsøvelse, ikke en platform til politikstyring og ikke et GRC-værktøj, der lagrer beviser efterhånden. Det definerende kendetegn er, at compliance-kontrollen kører i pipelinen, den er en del af leveringsprocessen, ikke et overlay oven på den. Et værktøj, der genererer compliance-rapporter fra systemlogfiler efter implementering, er ikke compliance-as-code. En gate i CI/CD-pipelinen, der blokerer implementering, når en compliance-regel overtrædes, er.

Tre egenskaber adskiller et modent compliance-as-code-program fra en delvis implementering:

Kontinuerlig, ikke periodisk. Overholdelseskontroller kører ved hver ændring, ikke kvartalsvis eller årligt. Systemets overholdelsesstatus er kendt ved hver commit, ikke på den sidste revisionsdato.

Forebyggende, ikke detektiv. Overtrædelser af regler og regler opdages, før de når produktionsstadiet, og opdages ikke efter en revision eller hændelse. Gaten blokerer den ikke-overensstemmende ændring; compliance-teamet forfølger den ikke efterfølgende.

Dokumenteret, ikke påstået. Overholdelseskontrollen producerer maskinlæsbart bevismateriale, en struktureret registrering af, hvad der blev kontrolleret, hvornår, med hvilket resultat, og efter hvilken politikversion. Revisoren forespørger bevismaterialet; de modtager ikke en skriftlig erklæring om, at kontrollerne blev fulgt.

De fire typer af compliance-kontroller i pipelines

Overholdelse af regler omfatter fire forskellige kategorier af kontroller, der hver især kræver forskellige implementeringsmønstre:

Type 1: Sikkerhedspolitiktjek

Statisk kodeanalyse, hemmelighedsdetektion, sårbarhedsscanning og SAST-regler, der håndhæver sikkerhedspolitikker som en betingelse for implementering. Disse er de mest modne compliance-as-code-kontroller. Semgrep, SonarQube, Snyk, Checkov og lignende værktøjer er blevet integreret i CI/CD-pipelines i årevis. En Semgrep-regel, der blokerer commits, der indeholder hardcodede legitimationsoplysninger, er en compliance-as-code-implementering af sikkerhedspolitikken "ingen hardcodede hemmeligheder".

Omhandlede lovgivningsmæssige rammer: SOC 2 (CC6.1-CC6.8 logisk adgang), PCI-DSS 4.0 (krav 6.3 sikkerhedstestning), ISO 27001 (A.14 sikker udvikling).

Type 2: Politiktjek af infrastruktur som kode

OPA (Open Policy Agent), Checkov og tfsec-regler, der validerer Terraform-, CloudFormation- og Kubernetes-manifester mod sikkerheds- og compliance-baselines, før infrastrukturen klargøres. En Rego-politik, der blokerer Terraform-konfigurationer med offentlige S3-buckets, er en compliance-as-code-implementering af politikken "ingen offentlige lagerbuckets". Disse kontroller kører mod infrastrukturdefinitionen før implementering, ikke mod den kørende infrastruktur bagefter.

Omhandlede lovgivningsmæssige rammer: CIS Benchmarks, NIST 800-53, SOC 2 (CC6.6 logisk adgang til netværk), FedRAMP-kontroller til cloud-miljøer.

Type 3: Datastyring og privatlivstjek

Automatiserede kontroller, der håndhæver datahåndteringspolitikker på kodeniveau: verificering af, at databaseskemaer ikke introducerer nye PII-kolonner uden passende klassificering, at API-slutpunkter, der eksponerer personoplysninger, har krævet godkendelse, og at dataopbevaringslogikken matcher den dokumenterede opbevaringspolitik. Disse kontroller er mindre modne i de fleste compliance-programmer, værktøjerne findes (Great Expectations, dbt-tests, brugerdefinerede Semgrep-regler), men politikdefinitionerne udtrykkes sjældent i maskinlæsbar form.

Omhandlede lovgivningsmæssige rammer: GDPR artikel 25 (databeskyttelse gennem design), HIPAA-sikkerhedsregel, CCPA, PCI-DSS 4.0 (krav 3 om beskyttelse af kortindehaveres data).

Type 4: Ændringskontrol og kontrol af funktionsadskillelse

Automatiseret verifikation af, at selve implementeringsprocessen overholder kravene til ændringskontrol: at implementeringsidentiteten ikke er den samme som autorisationsidentiteten (funktionsadskillelse), at de nødvendige godkendelser blev indhentet før implementering, at implementeringsvinduer blev overholdt, og at rollback-funktionaliteten findes og er dokumenteret. Disse kontroller kører ved implementeringsportalen i stedet for ved kodeanalyseportalen.

Omhandlede lovgivningsmæssige rammer: SOX ITGC (ændringsstyringskontroller), DORA operationel robusthed, ISO 20000 forandringsledelse.

Hvorfor kun 46% er startet: De virkelige barrierer

Adoptionstallet på 46 % for compliance-as-code er lavere end kendskabstallet antyder. Konceptet er bredt forstået; implementeringen er der, hvor organisationerne går i stå. Tre barrierer tegner sig for størstedelen af ​​kløften:

Vanskeligheder med at oversætte politikker. Regulatoriske krav er skrevet i et naturligt sprog, der er egnet til menneskelig fortolkning. Konvertering af dem til maskineksekverbare regler kræver både regulatorisk ekspertise (for at fortolke kravet korrekt) og teknisk ekspertise (for at udtrykke fortolkningen som kode). Samspillet mellem disse to færdigheder er sjældent. Et SOC 2-krav om, at "adgang til produktionssystemer er begrænset til autoriseret personale", kræver en specifik fortolkning (hvilket system, hvilket personale, hvad der udgør adgang, hvilket bevis for autorisation), før det kan udtrykkes som en gate-regel. At få denne fortolkning forkert resulterer i en compliance-kontrol, der består, når den underliggende kontrol overtrædes, hvilket er værre end ingen kontrol overhovedet.

Værktøjsfragmentering på tværs af porteføljen. Et compliance-program, der spænder over cloud-infrastruktur (Terraform + OPA), applikationskode (Semgrep + SonarQube), containerbilleder (Trivy + Cosign) og datapipelines (Great Expectations), skal koordinere beviser på tværs af fire forskellige værktøjsøkosystemer, hver med forskellige outputformater, forskellige bevisskemaer og forskellige fejltilstande. Aggregeringen af ​​disse beviser til et samlet revisionsspor kræver integrationsarbejde, som mange organisationer endnu ikke har udført.

Udelukkelse af ældre systemer. Standard implementeringen af ​​compliance-as-code antager en moderne applikationsleveringspipeline: Git-repository, CI/CD-platform, containerregister, cloud-implementeringsmål. COBOL-programmer på mainframes passer ikke til denne model. "Pipeline" for en ændring af mainframe-programmet er: rediger kildekode i et PDS (partitioneret datasæt), indsend en kompileret JCL, forfrem det kompilerede indlæsningsmodul til et testbibliotek, kør batch-UAT, forfrem til produktion. Der er ingen GitHub Actions-workflow, intet Docker-billede, ingen Kubernetes-implementering. Standard compliance-as-code-værktøjerne har ingen mekanisme til at knytte compliance-gates til denne proces.

Organisationer med mainframe-arbejdsbelastninger står over for et valg: implementere compliance-as-code til den moderne stak og acceptere, at den mest compliance-følsomme kode, COBOL-programmerne, der implementerer regulatoriske beregninger, forbliver uden for det automatiserede compliance-framework; eller løse problemet med mainframe-inkludering, før de hævder fuld compliance-as-code-dækning.

Pipeline-integration: Den moderne stak

For moderne applikationer følger integration af compliance-as-code et veletableret mønster:

yaml

# GitHub Actions: compliance gate pipeline
name: Compliance Gates

on:
  pull_request:
  push:
    branches: [main]

jobs:
  security-compliance:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Secret detection (SOC 2 CC6.1)
        uses: trufflesecurity/trufflehog@main
        with:
          extra_args: --only-verified

      - name: SAST scan (PCI-DSS 6.3)
        uses: semgrep/semgrep-action@v1
        with:
          config: >-
            p/owasp-top-ten
            p/secrets
            p/security-audit

      - name: Dependency vulnerability scan (PCI-DSS 6.3.3)
        run: |
          npm audit --audit-level=high
          # Fail if high or critical CVEs present

  iac-compliance:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Terraform policy check (CIS + NIST 800-53)
        uses: bridgecrewio/checkov-action@master
        with:
          framework: terraform
          check: CKV_AWS_20,CKV_AWS_57  # no public S3, encrypted at rest

  evidence-collection:
    needs: [security-compliance, iac-compliance]
    runs-on: ubuntu-latest
    steps:
      - name: Generate compliance attestation
        run: |
          cat > compliance-evidence.json << EOF
          {
            "run_id": "${{ github.run_id }}",
            "commit": "${{ github.sha }}",
            "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
            "checks": {
              "secret_detection": "passed",
              "sast": "passed",
              "dependency_scan": "passed",
              "iac_policy": "passed"
            },
            "policy_version": "v2.3.1",
            "auditable": true
          }
          EOF

      - name: Sign attestation (SLSA provenance)
        uses: sigstore/cosign-installer@v3
        # Cryptographically signs the evidence artifact

OPA-politiklaget tilføjer deklarativ regelhåndhævelse oven i pipeline-gates:

rego

# OPA Rego policy: enforce separation of duties
# Blocks deployment when author and approver are the same identity

package deployment.compliance

deny[msg] {
    input.deployment.approved_by == input.deployment.authored_by
    msg := sprintf(
        "Separation of duties violation: %v cannot approve their own deployment",

[input.deployment.authored_by]

) } deny[msg] { count(input.deployment.approvals) < 2 input.deployment.environment == “production” msg := “Produktionsimplementeringer kræver mindst 2 godkendelser” } deny[msg] { not input.deployment.change_ticket msg := “Produktionsimplementering kræver en tilknyttet ændringsanmodning” }

Frameworket behandler compliance som en førsteklasses, beregningsbar systemegenskab ved at kombinere deklarative politikker-som-kode, standardiseret bevisindsamling og kryptografisk verificerbare attestationer. Centralt for tilgangen er et Compliance Data Lakehouse, der transformerer heterogene pipeline-artefakter til et forespørgbart, tidsindekseret compliance-dataprodukt, hvilket muliggør revisionsklar bevisgenerering og løbende sikring.

Udfordringen med ældre systemer: COBOL og mainframe-pipelinen

GitHub Actions-arbejdsgangen ovenfor antager git, containere og et cloud-implementeringsmål. Ingen af ​​disse findes i standardarbejdsgangen for mainframe-ændringsstyring. De compliance-gates, der aktiveres ved hver pull-anmodning for en Java-mikroservice, har ingen native ækvivalent til et COBOL-program, der promoveres via AZ/OS Change Management System.

Mainframe-ækvivalenten til en CI/CD-compliance gate kræver en anden arkitektur:

Statisk analyse før promovering. Før et COBOL-kildemedlem promoveres fra udviklingsbiblioteket til testbiblioteket, køres et statisk analysetrin mod den opdaterede kilde. Dette trin kan udløses af ændringsstyringssystemet (IBM UrbanCode Deploy, Compuware ISPW, Broadcom ISPW) som en hook før promovering. Den statiske analyse kontrollerer for compliance-relevante mønstre: hardcodede legitimationsoplysninger i WORKING-STORAGE, ubeskyttet filadgang uden kontrol af FILE STATUS, beregningsrutiner, der omgår den autoriserede beregningssti.

Validering af JCL-ændringskontrol. JCL-ændringer er ikke kode i samme forstand som applikationslogik, men de har konsekvenser for overholdelse af regler: en JCL-ændring, der tilføjer en ny DD-sætning, der giver et batchjob adgang til et datasæt, det ikke skal have adgang til, er en overtrædelse af reglerne. Statisk analyse af JCL-ændringen, hvor den nye datasætadgang kontrolleres mod listen over autoriserede adgange, er en overholdelsesgrænse for mainframe-implementeringen.

Konsekvensanalyse som compliance-kontrol af grænseoverskridende ændringer. Når en ændring af en delt COBOL-kopibog påvirker snesevis af programmer samtidigt, er compliance-spørgsmålet: Er effekten af ​​denne ændring blevet vurderet og godkendt? Konsekvensanalysen, der identificerer hvert program, der inkluderer den ændrede kopibog, er i sig selv en compliance-kontrol. En ændring, der er godkendt for ét program, men ikke vurderet for dens 43 transitive afhængigheder, har ikke gennemført den krævede ændringskontrolproces.

COBOL

      *> Compliance-relevant pattern in COBOL: hardcoded credential
      *> Should be flagged by static analysis compliance gate
       WORKING-STORAGE SECTION.
       01  DB-CONNECTION.
           05  DB-HOST    PIC X(50) VALUE 'prod-db.internal.corp'.
           05  DB-USER    PIC X(20) VALUE 'svcaccount'.
           05  DB-PASS    PIC X(20) VALUE 'P@ssw0rd2019!'.
           *> ^ This is a compliance violation: hardcoded credential
           *> A compliance gate should catch this before promotion

Problemet med reguleringskodeksen: Når COBOL er compliance-kontrollen

Standardframing af compliance-as-code behandler compliance som en egenskab ved, hvordan kode implementeres, om den rigtige scanning blev kørt, om den rigtige godkendelse blev opnået, og om den rigtige policy gate blev håndhævet? For organisationer, der kører regulatoriske beregninger i COBOL, er denne framing ufuldstændig. COBOL-koden i sig selv er compliance-kontrollen.

En bank, der beregner den lovpligtige kapital under Basel III ved hjælp af et COBOL-program, bruger ikke COBOL til at implementere en applikation, der har compliance-krav. COBOL-programmet er compliance-kravet. Den beregning, det udfører, er den lovpligtige forpligtelse. Hvis COBOL-programmet indeholder en logisk fejl i kapitalberegningen, en forkert betingelse i en EVALUATE-gren, et tilfælde af manglende kant i tabsgivende-misligholdelsesmodellen, er denne fejl en manglende compliance-fejl, ikke et problem med softwarekvaliteten.

Transaktionshåndtering, afviklingslogik, compliance-kontroller og undtagelseshåndtering udvikler sig ofte direkte inden for disse systemer, efterhånden som produkter, regler og markedsforhold ændrer sig. Denne akkumulerede logik gør ældre platforme unikt værdifulde. Det forklarer også, hvorfor moderniseringsindsatsen begynder med at forstå, hvordan eksisterende systemer opfører sig, før man beslutter, hvordan de skal transformeres.

For disse systemer betyder compliance-as-code noget mere fundamentalt end pipeline gates: det betyder løbende strukturel verifikation af, at de programmer, der implementerer regulatoriske beregninger, matcher den regulatoriske specifikation. Denne verifikation kræver:

Ændringspåvirkningsomfang. Enhver ændring i et program, der implementerer en regulatorisk beregning, skal vurderes for, om den påvirker det regulerede output. En ændring i en visningsrutine, der ikke berører beregningsstien, har andre overholdelsesimplikationer end en ændring i COMPUTE-sætningen, der producerer tallet for regulatorisk kapital. Statisk analyse, der skelner mellem ændringer i beregningsstien og ændringer, der ikke er i beregningsstien, er grundlaget for denne scoping.

Validering af adfærdsækvivalens. Når et regulatorisk beregningsprogram ændres for at imødekomme en regulatorisk opdatering, rette en defekt eller forbedre ydeevnen, skal det modificerede program producere output svarende til originalen for alle inputkombinationer, som regulatoren kunne undersøge. Automatiseret testgenerering fra eksisterende produktions-input/output-par er compliance-as-code-tilgangen til validering af adfærdsækvivalens.

Meddelelse om ændring af afhængighed. En delt COBOL-kopibog, der definerer de datastrukturer, der bruges af et regulatorisk beregningsprogram, er en compliance-artefakt. Enhver ændring i den pågældende kopibog er en ændring i den regulatoriske beregnings datamodel. Compliance-gaten for kopibogsændringer, der påvirker regulatoriske programmer, kræver konsekvensanalyse, før ændringen godkendes, ikke efter at den allerede er blevet promoveret til produktion, og beregningen allerede er blevet kørt med den ændrede datamodel.

Opbygning af bevissporet

Den dokumentation, som compliance-as-code producerer, skal opfylde samme standard som den dokumentation, som manuelle compliance-processer producerer, men den skal ske automatisk, kontinuerligt og uden menneskelig indgriben. Bevissporet for en compliance-revision har fem påkrævede egenskaber:

EjendomKravImplementering
FuldstændighedEnhver compliance-relevant hændelse registreresGates kører ved hver implementering; ingen undtagelser uden dokumenteret risikoaccept
NøjagtighedBeviserne repræsenterer korrekt, hvad der blev kontrolleretMaskinlæsbart gate-output, ikke menneskeskrevne resuméer
IntegritetBevismateriale kan ikke ændres efter oprettelseKryptografisk signering (Cosign), uforanderlig lagring (kun tilføjelse af revisionslog)
RettidighedBevismaterialet indhentes på tidspunktet for begivenhedenGenereret af pipelinen på udførelsestidspunktet, tidsstemplet af CI-systemet
ForespørgselsevneRevisorer kan indhente specifik dokumentation efter anmodningIndekseret bevislager med forespørgselsfunktion; ingen manuel bevissøgning

SBOM-generering, SLSA-tilpasset proveniens og attestation skal ske, efterhånden som koden bevæger sig gennem pipelinen, ikke gennem manuelle revisioner. Compliance- og governance-implikationer for DevOps omfatter: Attestationer, formelle erklæringer om byggeprocesser, afhængigheder og proveniens integreret i pipelines; og artefaktsignering, der kryptografisk verificerer integriteten af ​​byggeoutput.

For ældre mainframe-systemer har bevissporet et yderligere krav: beviserne skal dække mainframe-forfremmelseshændelsen, ikke kun den moderne implementering. En compliance-revision, der viser bevis for automatiserede gates for hver Java-mikroservice-implementering, men ikke har automatiseret bevis for COBOL-programforfremmelser, har et dækningshul, som en revisor vil finde.

Hvordan SMART TS XL Understøtter compliance-as-code i ældre miljøer

SMART TS XL Leverer det statiske analysefundament, der muliggør compliance-as-code for COBOL- og JCL-laget, hvor standard CI/CD-complianceværktøjer ikke kan nå.

Funktionen til statisk kodeanalyse scanner COBOL-programmer for compliance-relevante mønstre før enhver forfremmelse: hardcodede legitimationsoplysninger i WORKING-STORAGE, FILE STATUS-deklarationer, der aldrig kontrolleres (et compliance-gab for fejlhåndtering), ubeskyttet adgang til følsomme datasæt og beregningsrutiner, der afviger fra det godkendte algoritmiske mønster. Disse resultater er compliance gate-outputtet for COBOL-ændringer, hvilket svarer til Semgrep-resultater for Java, udtrykt som strukturerede resultater, der kan inkluderes i evidenssporet.

Programafhængighedskortlægningen muliggør overholdelseskontrol af konsekvensanalyse: Før en ændring af kopibogen godkendes, opregner afhængighedskortet alle programmer, der inkluderer kopibogen, og alle regulatoriske beregningsprogrammer blandt disse markeres som værende nødvendige for yderligere overholdelsesgennemgang. Dette er en automatiseret konsekvensvurdering af ændringer, den overholdelsesgate, der sikrer, at regulerede programmer ikke påvirkes af ændringer, der er godkendt til en ikke-reguleret kontekst.

Effektanalysefunktionen producerer det strukturerede effektomfang, som compliance-arbejdsgange kræver: ikke blot "denne skrivebog bruges af 47 programmer" , men "ud af disse 47 programmer er 12 i den regulatoriske beregningsproces og kræver compliance-godkendelse, før denne ændring kan fremmes." Denne omfangsrige effektanalyse er beviset på, at kravet om ændringskontrol til compliance blev opfyldt.

Virksomhedssøgningsfunktionen gør det muligt at forespørge på compliance-dokumentation til støtte for revisionssvar: find alle programmer, der blev ændret i et bestemt tidsvindue, alle ændringer , der berørte et regulatorisk beregningsprogram, alle JCL-modifikationer, der tilføjede adgang til et compliance-følsomt datasæt. Denne forespørgselsfunktion fungerer som revisionsspor for ændringer i ældre systemer og er beviset for, at compliance-kravet til ændringskontrol løbende blev opfyldt, ikke kun ved det sidste øjebliksbillede.

For organisationer, der udfører arvemodernisering programmer, SMART TS XLs compliance-analyse giver et overholdelsesgrundlag før migrering: de programmer, der implementerer lovgivningsmæssige beregninger, de datastrukturer, de er afhængige af, og den ændringshistorik, der demonstrerer kontinuerlig compliance gennem moderniseringsprocessen.

Overholdelse af regler er et teknisk problem, ikke et dokumentationsproblem

De organisatoriske omkostninger ved at behandle compliance som et dokumentationsproblem, indsamle beviser efterfølgende, afstemme politikdokumenter med systemlogfiler og udarbejde revisionspakker under pres fra deadlines kan måles i spildte ingeniørtimer, compliance-teamets overarbejde og den løbende risiko for et fund, der kunne have været forhindret af en gate, der aldrig eksisterede.

Compliance som kode tilbyder en løsning på problemet med manuel, reaktiv GRC. Det giver kontinuerlig revisionsberedskab med minimal overhead, hurtigere udgivelseshastighed og udviklere, der endelig kan fokusere på at bygge bedre systemer i stedet for at udfylde formularer.

Den tekniske udfordring ved compliance-as-code er ikke primært teknisk. Værktøjerne findes til alle moderne applikationsstak, og de forbedres hurtigt. Udfordringen er oversættelse af politikker, konvertering af lovgivningsmæssige krav til eksekverbare regler og udvidelse af dækningen, inklusive de ældre systemer, hvor den mest compliance-følsomme kode rent faktisk findes.

For organisationer, der kører regulatoriske beregninger i COBOL, er compliance-as-code ikke fuldført, før COBOL-promoveringspipelinen har den samme automatiserede gate-dækning som Java-implementeringspipelinen. Den compliance-kontrol, der kører kl. 2, når batchjobbet promoveres til produktion, er mere værd end den bevisindsamling, der finder sted kl. 10 morgenen før revisoren ankommer.