<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Johan Louwers on Medium]]></title>
        <description><![CDATA[Stories by Johan Louwers on Medium]]></description>
        <link>https://medium.com/@louwersj?source=rss-a68671a6ad8d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*12-bqhsdUgzgkaRHtc9Plw.jpeg</url>
            <title>Stories by Johan Louwers on Medium</title>
            <link>https://medium.com/@louwersj?source=rss-a68671a6ad8d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 04:10:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@louwersj/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[[SOLVED] Oracle Linux installation network timeout]]></title>
            <link>https://louwersj.medium.com/solved-oracle-linux-installation-network-timeout-977aed0c5f61?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/977aed0c5f61</guid>
            <category><![CDATA[linux-kernel]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[oracle]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Sun, 20 Sep 2026 08:53:48 GMT</pubDate>
            <atom:updated>2026-09-20T08:53:48.397Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*98DyGawf5S8W_JzxaWjQGQ.png" /><figcaption>error message</figcaption></figure><p>I recently experienced serious issues on my lab network due to some misconfigurations of network equipment. Although communication was still possible, we experienced packet loss as well as extreme latency. Irritating as it was, it gave an interesting dimension to a basic Oracle Linux installation, where the installer would try to download packages from the nearest mirror and fail at different stages during different attempts.</p><p>As it turns out, the timeout for waiting for a mirror to respond is set to a very short period by default. Because we were experiencing network issues, we would hit that timeout. Although the error message shown above was not particularly descriptive, it was quite clear that this was the root cause.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zP95ONkiGAliVVEB6qzTwA.png" /></figure><p>When encountering such an error, you can resolve it by adding the following boot option: inst.repo.timeout=60. This instructs the installer to wait 60 seconds before failing.</p><h3>About the author(s)</h3><p>Johan Louwers is currently Chief Enterprise Architect for a large global tech company as well as the lead architect for NATO and a number of industrial, military &amp; governmental organisations. Johan has a strong and long background in the field of Enterprise Architecture and complex system engineering. Having worked with enterprises in a diverse set of industries as (enterprise) architect, CTO and technical and strategic business advisor Johan brings both deep technical knowledge to the table as well as strong business oriented expertise. In addition to this Johan is a tech addict who tends to enjoy supporting open source initiatives and actively coding as a hobby. Views expressed in this post are personnel and do not necessarily reflect the views of my current employer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=977aed0c5f61" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When Java Is Still the Right Choice for Durable Mission Services]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://louwersj.medium.com/when-java-is-still-the-right-choice-for-durable-mission-services-4a8ce803b450?source=rss-a68671a6ad8d------2"><img src="https://cdn-images-1.medium.com/max/1672/1*ObyhCeqrhogCm9zie7L9nQ.png" width="1672"></a></p><p class="medium-feed-snippet">There are services where a small script is enough, and there are services where the runtime itself becomes part of the architecture. The&#x2026;</p><p class="medium-feed-link"><a href="https://louwersj.medium.com/when-java-is-still-the-right-choice-for-durable-mission-services-4a8ce803b450?source=rss-a68671a6ad8d------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://louwersj.medium.com/when-java-is-still-the-right-choice-for-durable-mission-services-4a8ce803b450?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a8ce803b450</guid>
            <category><![CDATA[defense]]></category>
            <category><![CDATA[defence]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[military]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Mon, 20 Jul 2026 08:04:00 GMT</pubDate>
            <atom:updated>2026-07-20T08:04:00.607Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Threat Modeling the Deployment, Not Only the Code]]></title>
            <link>https://louwersj.medium.com/threat-modeling-the-deployment-not-only-the-code-2226344a84b3?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/2226344a84b3</guid>
            <category><![CDATA[military]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[defense]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Mon, 13 Jul 2026 07:34:39 GMT</pubDate>
            <atom:updated>2026-07-13T07:34:39.255Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P4c_Y2VEZICd_8V415ogqg.png" /><figcaption><strong>Threat Modeling the Deployment, Not Only the Code</strong></figcaption></figure><p>A team can do a respectable security review and still deploy a fragile system. The code has input validation, the dependency scanner is clean enough, the secrets are not hard-coded, and the merge request contains a threat-model diagram. Then the workload starts with a host path mount, a broad service account, unrestricted egress, and access to a secret it does not need.</p><p>The issue is not that code threat modeling is wrong. The issue is that the running system has a larger attack surface than the source repository shows. In modern software, the runtime includes deployment manifests, container settings, workload identity, network policy, secrets, admission controls, observability, operator workflows, and recovery paths. If those are not part of the threat model, the model describes only a draft of the system.</p><p>This article looks at runtime threat modeling as an architecture practice. In EU and NATO-aligned mission environments, defence software is judged not only by whether it compiles or passes tests, but by whether it remains controlled under pressure. The practical lesson is simple: threat models should follow the software into the runtime, because that is where many exploitable weaknesses become reachable.</p><h4><strong>The architecture problem</strong></h4><p>Threat modeling is often introduced as an application design activity. Teams identify assets, trust boundaries, attackers, data flows, and mitigations. That is useful, but it can become too narrow when the runtime is treated as an implementation detail. A service does not run as “code”; it runs as a process inside a configured environment with privileges, credentials, routes, dependencies, and operational assumptions.</p><p>Consider a service that processes mission events. The code may correctly validate incoming JSON, reject unknown fields, and avoid obvious injection risks. But the container may run with unnecessary Linux capabilities, the pod may reach every internal network, the service account may list secrets across a namespace, and the log pipeline may emit sensitive payloads. None of those problems is fixed by adding another validation function.</p><p>The architecture problem is that the threat boundary has moved. It now crosses CI pipelines, artifact registries, orchestration layers, identity systems, network controls, secrets stores, and runtime monitoring. If the threat model stops at the codebase, architects miss the controls that determine what a compromised workload can actually do.</p><p>Runtime threat modeling does not replace secure coding. It adds the missing operational layer. The question is not only “what can go wrong in this function?” It is also “what can this workload reach, read, modify, emit, and hide once it is running?”</p><h4><strong>Why this matters</strong></h4><p>In a military mission system, a small runtime assumption can become a major operational weakness. A workload with broad egress can move data to the wrong place. A service account with unnecessary read rights can expose records that were never meant for that process. A misconfigured sidecar can turn a narrow service into a wider trust path. These failures are not dramatic by themselves, but they can undermine command-and-control support and incident response.</p><p>For European and NATO interoperability, runtime discipline also affects trust between partners. A mission partner environment may accept a software capability only when its deployment posture, audit path, and data controls can be explained. The same source code can be acceptable in one runtime and unacceptable in another because the surrounding controls differ.</p><p>The reader role is usually architectural rather than purely defensive. Enterprise architects, platform engineers, security architects, and service owners need a shared language for runtime risk. Without that language, security review becomes a late checklist and operations inherit decisions they did not see.</p><h4><strong>Reference architecture</strong></h4><p>A practical reference architecture begins with the application design threat model, but does not end there. The first layer is source and dependency control: code review, static analysis, dependency pinning, provenance, and artifact signing. These controls reduce the chance of shipping a known weakness, but they do not define what the running workload is allowed to do.</p><p>The second layer is deployment intent. Manifests, Helm charts, GitOps configuration, systemd units, Terraform modules, and policy bundles should describe the expected runtime posture. This includes user identity, filesystem access, Linux capabilities, container privileges, resource limits, network egress, ingress paths, secret mounts, and log handling. Treat those files as architecture artifacts, not operational noise.</p><p>The third layer is admission and policy enforcement. Before a workload starts, the platform should reject configurations that violate the threat model. Kubernetes Pod Security Standards are a useful example because they make privilege, host access, and container hardening visible. Policy-as-code tools such as Open Policy Agent can express local rules for required labels, denied capabilities, restricted egress, and allowed secret references.</p><p>The fourth layer is runtime observation. A threat model that cannot be observed will decay. Runtime detection should look for unexpected shell execution, unusual file reads, changes to sensitive paths, connections outside the allowed set, suspicious process trees, or abnormal privilege use. Falco is one open-source example of this pattern because it can reason about system-call and container activity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7vzUbOYxz83q1SpJop_3WA.png" /></figure><p>The diagram shows the threat model crossing from source into the runtime platform. Notice that threat assumptions feed both admission policy and detection rules. This is the important shift: a threat model is no longer only a design conversation. It becomes a set of checks, boundaries, and evidence streams.</p><h4><strong>Runtime view</strong></h4><p>At the runtime level, the unit of analysis is the workload posture. A workload posture describes how the service runs: identity, privileges, filesystem access, network reachability, secrets, data paths, and telemetry. This is different from the application feature list. Two deployments of the same binary can have different risk profiles if one has broad secrets access and another has a narrow, auditable identity.</p><p>Start by mapping what the workload can reach. That means network egress, service discovery, database permissions, message topics, object storage buckets, and administrative APIs. Then map what the workload can read locally: mounted files, injected secrets, configuration, certificates, temporary storage, and logs. Finally, map what the workload can hide or damage: audit streams, health checks, metrics, queues, caches, and local buffers.</p><p>The most useful runtime threat models are testable. If the model says the service must not call external addresses, there should be a policy and a test. If the model says the service must not read another service’s secrets, there should be a namespace, identity, and admission rule. If the model says unexpected shell execution is suspicious, there should be a detection rule and an incident path.</p><h4><strong>Implementation pattern</strong></h4><p>A Python-based implementation can help turn runtime assumptions into reviewable policy input. The example below is deliberately small. It models a deployment posture and returns findings before the workload is allowed into a protected runtime.</p><pre>from dataclasses import dataclass<br><br><br>@dataclass(frozen=True)<br>class RuntimePosture:<br>    service_name: str<br>    privileged: bool<br>    host_path_mounts: list[str]<br>    linux_capabilities: list[str]<br>    secret_refs: list[str]<br>    allowed_egress: list[str]<br>    service_account_scope: str<br><br><br>def review_posture(posture: RuntimePosture) -&gt; list[str]:<br>    findings: list[str] = []<br><br>    if posture.privileged:<br>        findings.append(&quot;privileged runtime is not allowed for this service&quot;)<br><br>    if posture.host_path_mounts:<br>        findings.append(&quot;host path mounts require architecture approval&quot;)<br><br>    risky_caps = {&quot;SYS_ADMIN&quot;, &quot;NET_ADMIN&quot;, &quot;DAC_READ_SEARCH&quot;}<br>    requested = set(posture.linux_capabilities)<br>    if risky_caps &amp; requested:<br>        findings.append(f&quot;risky Linux capabilities requested: {sorted(risky_caps &amp; requested)}&quot;)<br><br>    if len(posture.secret_refs) &gt; 2:<br>        findings.append(&quot;secret access looks broader than the service contract&quot;)<br><br>    if &quot;*&quot; in posture.allowed_egress:<br>        findings.append(&quot;unrestricted network egress violates the runtime threat model&quot;)<br><br>    if posture.service_account_scope not in {&quot;service&quot;, &quot;namespace&quot;}:<br>        findings.append(&quot;service account scope is too broad&quot;)<br><br>    return findings</pre><p>In production, this logic would usually live in policy-as-code, admission control, CI checks, or a platform guardrail service. The point is the shape of the control. The threat model is translated into checks that can stop a risky deployment and create evidence for later review.</p><h4><strong>Failure modes and trade-offs</strong></h4><p>The first failure mode is the clean code, unsafe runtime pattern. The source is reviewed, but the deployment grants broad privilege. This usually happens when delivery pressure pushes teams to copy an old manifest or use a permissive default to make an integration work. The mitigation is to make the runtime posture visible before deployment and enforce the obvious deny rules automatically.</p><p>The second failure mode is threat-model drift. The first version of the model is good, but the service later adds a queue, a database, a file export, or a debug endpoint. If the threat model is not updated with the deployment, the evidence becomes historical rather than operational. Drift is reduced when policy checks and runtime detections are generated from the same assumptions.</p><p>The third failure mode is detection without ownership. A runtime tool can raise an alert, but nobody knows whether the behavior violates the model. Good architecture links runtime events to service owners, threat assumptions, and response paths. Otherwise the alert is only noise with better formatting.</p><p>There are trade-offs. Strict runtime policy can slow teams when the exception path is unclear. Runtime detection can produce false positives if it is not tuned to the service contract. More granular secrets and network boundaries improve containment, but they require better platform automation. The answer is not to make every team a security specialist. The answer is to make the secure runtime the normal runtime.</p><h4><strong>Technology mapping</strong></h4><p>The capability stack starts with code and dependency review, using static analysis, dependency scanning, artifact signing, and provenance records. It then moves into deployment and admission controls. Kubernetes Pod Security Standards, Open Policy Agent, and GitOps review checks can prevent risky runtime states before the workload starts.</p><p>Runtime visibility can be built with Falco, OpenTelemetry, Prometheus, Grafana, and platform logs. These tools should not be deployed as decoration. They should be connected to threat assumptions: unexpected process execution, forbidden egress, secret access, or changes to sensitive files. In an Oracle-oriented environment, Oracle Linux may be part of the runtime baseline, but the threat model should remain portable across Linux and container platforms.</p><p>The data layer also matters. PostgreSQL, NATS, Kafka, object storage, and API gateways all have their own runtime permissions and audit paths. A service threat model should include the permissions it has on these dependencies, not only the code it runs.</p><h4><strong>Evidence and observability</strong></h4><p>Evidence should answer three questions. What did we believe could go wrong? What control was meant to prevent or detect it? What happened at runtime? If the system cannot answer those questions, the threat model is not operational.</p><p>Useful evidence includes policy evaluation results, denied deployments, runtime detection events, secret-access logs, network-policy decisions, workload identity records, and incident annotations. Synthetic tests can help. A test workload that requests forbidden egress should be denied. A workload that tries to mount a restricted host path should fail admission. A suspicious command execution should produce a detection event.</p><p>The best evidence is boring. It appears during normal delivery and normal operation, not only after an incident. That is how threat modeling becomes part of engineering rather than a document kept outside the system.</p><h4><strong>Key takeaways</strong></h4><ul><li>Threat models should include runtime posture, not only application code.</li><li>Deployment manifests, identities, secrets, and network paths are architecture artifacts.</li><li>Admission policy and runtime detection should be derived from threat assumptions.</li><li>Evidence matters: controls must be testable before deployment and observable after deployment.</li></ul><p>The architecture principle is this: model the system as it runs, not only as it is written. A service is its code plus its identity, privileges, dependencies, data paths, and operational controls. Architects should make those runtime facts explicit because they protect containment, auditability, and mission assurance when conditions are no longer ideal.</p><h4><strong>About the author(s)</strong></h4><p>Johan Louwers is currently Chief Enterprise Architect for a large global tech company as well as the lead architect for NATO and a number of industrial, military &amp; governmental organisations. Johan has a strong and long background in the field of Enterprise Architecture and complex system engineering. Having worked with enterprises in a diverse set of industries as (enterprise) architect, CTO and technical and strategic business advisor Johan brings both deep technical knowledge to the table as well as strong business oriented expertise. In addition to this Johan is a tech addict who tends to enjoy supporting open source initiatives and actively coding as a hobby. Views expressed in this post are personnel and do not necessarily reflect the views of my current employer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2226344a84b3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python Automation for Mission Event Sink Operations]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://louwersj.medium.com/python-automation-for-mission-event-sink-operations-21a4b8967177?source=rss-a68671a6ad8d------2"><img src="https://cdn-images-1.medium.com/max/1689/1*o2x3YEiEBGzosQBJKBHpiw.png" width="1689"></a></p><p class="medium-feed-snippet">The most dangerous operational script is not the one that fails loudly. It is the one that succeeds quickly while weakening the delivery&#x2026;</p><p class="medium-feed-link"><a href="https://louwersj.medium.com/python-automation-for-mission-event-sink-operations-21a4b8967177?source=rss-a68671a6ad8d------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://louwersj.medium.com/python-automation-for-mission-event-sink-operations-21a4b8967177?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/21a4b8967177</guid>
            <category><![CDATA[data]]></category>
            <category><![CDATA[nats-streaming]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[defence]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 07:52:49 GMT</pubDate>
            <atom:updated>2026-07-10T07:52:49.817Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Using Low-Level Diagnostics When Dashboards Are Not Enough]]></title>
            <link>https://louwersj.medium.com/using-low-level-diagnostics-when-dashboards-are-not-enough-410292d26bc9?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/410292d26bc9</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 11:12:02 GMT</pubDate>
            <atom:updated>2026-07-06T11:12:02.245Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KwWssEspPAytPcYnLgEogw.png" /><figcaption>Using Low-Level Diagnostics When Dashboards Are Not Enough</figcaption></figure><p>The dashboard is green until it is not useful. Requests are slower, operators can feel it, and the support channel starts filling with careful but worrying observations. The service graph says the dependency is healthy. The metrics show a mild latency increase. The logs contain no obvious exception. The system is online, but the explanation is missing.</p><p>This is where low-level diagnostics earn their place. They are not a replacement for normal observability, and they are not something to leave running everywhere without thought. They are the next layer down when metrics, logs, and traces describe the symptom but not the mechanism. In a mission environment, that distinction matters because incident response needs evidence, not only a colored panel.</p><p>This article looks at low-level diagnostics as an architecture capability. The practical lesson is not that every architect must become a kernel engineer. The lesson is that platform architecture should include a controlled path from dashboards to host behavior, system calls, scheduling, file access, and network reality.</p><h4><strong>The architecture problem</strong></h4><p>Modern observability usually starts with three signals: metrics, logs, and traces. Metrics show what is changing over time. Logs explain selected events. Traces connect requests across services. Together they are powerful, and they should remain the first line of operational visibility.</p><p>The problem is that many failures are created below the level where application telemetry is rich. A process may be blocked on file I/O, waiting on DNS, hitting a permission error, retrying a socket call, contending on CPU scheduling, or suffering from kernel-level packet handling delays. The application may not log those details because it does not know them, or because the failing layer is hidden behind a library.</p><p>When that happens, teams often guess. They restart pods, scale replicas, roll back code, or blame the network. Sometimes that works. Sometimes it destroys the evidence. The architecture problem is the missing diagnostic ladder: a safe, rehearsed way to move from service-level dashboards into lower-level runtime observation without turning an incident into an experiment.</p><p>Low-level diagnostics need boundaries. strace, perf, ftrace, and eBPF-based tools can expose sensitive data or add overhead if used carelessly. They can also overwhelm operators with information. The architecture should define when to use them, who may use them, where the evidence goes, and how the findings feed back into platform design.</p><h4><strong>Why this matters</strong></h4><p>In defence and intelligence systems, operational confidence depends on being able to explain failure without unnecessary disruption. A military command-and-control support service may degrade because of a slow local disk, a blocked resolver, or a kernel queue that is not visible in a normal service dashboard. If the team only sees application metrics, the incident can become a sequence of guesses.</p><p>EU and NATO-aligned mission environments also bring constraints around access, audit, and evidence handling. Not every operator should be allowed to attach arbitrary probes to every process. Not every diagnostic trace should be copied outside the secure enclave. A useful architecture gives teams deeper visibility while preserving need-to-know access and operational control.</p><p>The value is not only during incidents. Low-level diagnostics help architects validate assumptions during testing, recovery exercises, and degraded connectivity drills. They show where a service really waits, what a runtime actually opens, which system calls dominate latency, and whether a supposedly isolated workload is doing more than the design said it would do.</p><h4><strong>Reference architecture</strong></h4><p>A useful reference architecture starts with normal observability. Service metrics, logs, and distributed traces should be collected consistently, with enough context to identify workload, version, node, request path, and dependency. OpenTelemetry is a good open-source reference point here because it gives teams a portable model for instrumentation and telemetry flow.</p><p>The second layer is host and runtime context. This includes process state, file descriptors, socket tables, DNS behavior, CPU pressure, memory pressure, cgroup limits, container runtime events, and node-level logs. These signals explain whether a service problem is actually a host problem, a scheduling problem, or a resource boundary problem.</p><p>The third layer is targeted low-level diagnostics. strace can show system calls for a process. perf can help profile CPU behavior. ftrace can expose kernel tracing paths. bpftrace and other eBPF-based tools can attach focused probes to kernel or user-space events. These tools should be used with a hypothesis, a time box, and a clear evidence destination.</p><p>The fourth layer is evidence and decision support. Diagnostic output should not live only in a terminal scrollback. It should be captured, redacted when needed, linked to the incident, and used to change the architecture. If eBPF shows that a service spends incident time waiting on DNS, that finding should influence caching, resolver placement, timeout policy, and readiness tests.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Me2hAsXIsSQRzME10AdnDg.png" /></figure><p>The diagram shows low-level diagnostics as an escalation path, not a parallel universe. Dashboards remain the top of the ladder. When they cannot explain the failure, the team moves down into traces, host runtime, syscalls, and eBPF probes, with every step feeding evidence into an incident decision.</p><h4><strong>Under the hood</strong></h4><p>At the Linux runtime layer, many application symptoms become system-call patterns. A slow request may be a long sequence of `connect`, `poll`, read, or `futex` calls. A failing configuration load may be repeated `openat` errors. A noisy retry loop may show up as frequent socket creation. This is why syscall-level tools remain useful even in containerized platforms.</p><p>eBPF adds another angle because it can observe selected kernel or user-space events with lower overhead than many older tracing approaches when used correctly. It is not magic. It is a programmable observation mechanism that still needs guardrails, permissions, and careful scope. bpftrace makes the idea approachable because it lets an operator express focused probes for counts, timings, and stack traces.</p><p>The important distinction is that low-level diagnostics should be hypothesis-driven. “Attach everything and see what happens” is rarely a good operational pattern. A better pattern is: identify the symptom, form a runtime hypothesis, run the smallest safe probe, capture evidence, then stop the probe. That keeps diagnostics useful and reduces the risk of turning observation into a new failure source.</p><h4><strong>Implementation pattern</strong></h4><p>For this topic, a bpftrace-style example is more appropriate than a Python example because the problem sits near Linux runtime behavior. The example below counts slow `connect` system calls by process name. It is the kind of focused probe that can help verify whether a latency incident is related to outbound connection setup rather than application logic.</p><pre>tracepoint:syscalls:sys_enter_connect<br>{<br>  @start[tid] = nsecs;<br>  @comm[tid] = comm;<br>}<br><br>tracepoint:syscalls:sys_exit_connect<br>/@start[tid]/<br>{<br>  $duration_ms = (nsecs - @start[tid]) / 1000000;<br><br>  if ($duration_ms &gt; 100) {<br>    @slow_connects[@comm[tid]] = count();<br>    @slow_connect_time[@comm[tid]] = sum($duration_ms);<br>  }<br><br>  delete(@start[tid]);<br>  delete(@comm[tid]);<br>}</pre><p>The point is not to run this exact probe everywhere. The point is the diagnostic shape. The operator has a hypothesis, the probe is narrow, the threshold is explicit, and the output can be captured as incident evidence. In production, the script would be reviewed, time-bounded, and run only by authorized operators on approved nodes.</p><p>The same pattern works for file access, DNS behavior, process execution, scheduler delay, or unexpected privilege use. Keep the probe small. Know what question it answers. Stop it when the answer is collected.</p><h4><strong>Failure modes and trade-offs</strong></h4><p>The first failure mode is dashboard overconfidence. Teams assume that because the dashboard is green, the system is understood. In reality, a dashboard can aggregate away the detail that matters. The mitigation is to design dashboards as entry points into investigation, not as the full evidence model.</p><p>The second failure mode is uncontrolled probing. Low-level tools can reveal sensitive paths, payload fragments, process arguments, or credentials if used carelessly. They can also consume resources or confuse the incident timeline. In a secure mission enclave, diagnostics must be authorized, logged, scoped, and stored with the same discipline as other operational evidence.</p><p>The third failure mode is evidence loss. A team runs the right command during an incident, sees the answer, fixes the problem, and leaves no durable record. The next incident starts from zero. Diagnostic results should feed post-incident review, architecture decisions, runbooks, and automated tests.</p><p>The trade-off is depth versus safety. The deeper the diagnostic, the closer it gets to sensitive runtime behavior. That does not mean avoiding low-level diagnostics. It means making them part of the platform operating model, with preapproved probes, operator training, audit logs, and clear stop conditions.</p><h4><strong>Technology mapping</strong></h4><p>The normal observability layer can use OpenTelemetry for instrumentation, Prometheus for metrics, Grafana for dashboards, and a log stack suited to the environment. The host and runtime layer can use Linux process tools, container runtime events, node logs, and cgroup metrics. The low-level layer can use strace, perf, ftrace, bpftrace, and eBPF-based tools where the platform permits them.</p><p>In Kubernetes environments, node access and diagnostic privileges should be controlled carefully. Debug containers, node shells, and privileged probes can be useful, but they should not become routine shortcuts. In an Oracle-oriented estate, Oracle Linux may be part of the operating-system baseline, but the diagnostic architecture should be described in Linux and open-standards terms first.</p><p>The architecture should also separate always-on telemetry from on-demand diagnostics. Always-on telemetry should be cheap, safe, and broadly available. On-demand diagnostics can be deeper, but they require approval, scope, time limits, and evidence handling.</p><h4><strong>Evidence and observability</strong></h4><p>Evidence from low-level diagnostics should be stored with context: incident identifier, operator, node, process, workload version, probe used, start and stop time, and reason for use. Without that context, diagnostic output becomes a pile of interesting lines rather than operational evidence.</p><p>The observability platform should make escalation visible. A dashboard alert should link to recent traces, related logs, node pressure, and approved diagnostic runbooks. If a low-level probe is executed, the fact that it ran should be captured. This protects both the operator and the system.</p><p>Over time, repeated low-level findings should become higher-level signals. If incidents repeatedly require a DNS latency probe, the platform probably needs better DNS metrics. If file-open errors repeatedly explain startup failures, the application and deployment checks need improvement. Diagnostics should improve the architecture, not become a permanent manual dependency.</p><h4><strong>Key takeaways</strong></h4><ul><li>Dashboards are the start of investigation, not the whole diagnostic model.</li><li>Low-level tools such as strace, perf, ftrace, and bpftrace should be controlled, scoped, and evidence-driven.</li><li>A diagnostic ladder helps teams move from symptoms to mechanisms without guessing.</li><li>Findings from low-level diagnostics should feed architecture decisions, runbooks, and automated checks.</li></ul><p>The architecture principle is this: design observability so teams can descend safely from service symptoms to runtime mechanisms. Metrics, logs, and traces explain much of the system, but not all of it. A mission platform protects readiness when it provides controlled, auditable diagnostics for the moments where the normal dashboard cannot explain what the system is actually doing.</p><h4><strong>About the author(s)</strong></h4><p>Johan Louwers is currently Chief Enterprise Architect for a large global tech company as well as the lead architect for NATO and a number of industrial, military &amp; governmental organisations. Johan has a strong and long background in the field of Enterprise Architecture and complex system engineering. Having worked with enterprises in a diverse set of industries as (enterprise) architect, CTO and technical and strategic business advisor Johan brings both deep technical knowledge to the table as well as strong business oriented expertise. In addition to this Johan is a tech addict who tends to enjoy supporting open source initiatives and actively coding as a hobby. Views expressed in this post are personnel and do not necessarily reflect the views of my current employer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=410292d26bc9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Label-Aware Services for Compartmented Mission Data]]></title>
            <link>https://louwersj.medium.com/label-aware-services-for-compartmented-mission-data-c5413f495620?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5413f495620</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[military]]></category>
            <category><![CDATA[defense]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Tue, 30 Jun 2026 15:15:44 GMT</pubDate>
            <atom:updated>2026-06-30T15:15:44.694Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aVfEtCf9-Xx2TKG7KuAPnw.png" /><figcaption>Label-Aware Services for Compartmented Mission Data</figcaption></figure><p>A service can pass every ordinary health check and still be unsafe to use. The API responds, the database is online, the message bus is flowing, and the dashboard shows green. Then an analyst opens a record that should have stayed inside another compartment, or a mission application exports data to a partner enclave without preserving the releasability caveat that gave the record its meaning.</p><p>That failure rarely starts with a malicious action. It often starts with an architecture that treats labels as metadata for humans rather than policy input for systems. The label sits in a document footer, a database column, a case-management screen, or a filename convention, while the service makes its access decision from a role, a group, or a network location. The system has security controls, but the controls are not looking at the fact that matters.</p><p>This article looks at label-aware services as an architecture problem, not as a product feature. In EU and NATO-aligned mission environments, compartmented data is not only about hiding information. It is about controlled sharing, chain of custody, need-to-know access, and confidence that a mission partner environment receives only what it is meant to receive. The practical lesson is simple: a service that handles compartmented data should treat the data label as part of the runtime contract.</p><h4><strong>The architecture problem</strong></h4><p>Compartmentalization is usually described in organizational language: clearances, communities of interest, caveats, national release rules, and need-to-know. The architecture version is more concrete. A subject wants to perform an action on an object in a given environment, and the system must decide whether that action is allowed. The subject may be a person, a service account, a workload identity, or an automated process. The object may be a document, event, intelligence record, image, graph edge, case note, or message.</p><p>Role-based access control is useful, but it is not enough for this problem. A role can say that an analyst may read reports, but it does not always express whether that analyst may read this report, with this label, in this context, for this mission thread. Mandatory access control helps when labels and clearances follow a strict dominance model, but many systems also need attribute-based decisions, releasability checks, provenance checks, and operational context.</p><p>Network segmentation is also useful, but it is a supporting control. Kubernetes NetworkPolicy, firewalls, service meshes, and subnet boundaries can reduce the blast radius of a compromised service. They do not understand whether a data object is releasable to a specific coalition partner, whether a caveat has expired, or whether the source provenance is still trusted. If the architecture relies only on the network, it creates a comfortable illusion: the workload is in the right place, therefore the data must be safe.</p><p>The failure mode is easy to miss because every component can be doing a reasonable local job. Identity confirms the user, the API confirms the role, and the database returns the row. The problem is that no component has been made responsible for evaluating the full access decision against the data label and recording the evidence.</p><h4><strong>Why this matters</strong></h4><p>In a defence environment, the cost of a label mistake is not only confidentiality loss. It can break interoperability, reduce trust between partners, and make later audit work painfully uncertain. A military mission system may need to support a common operating picture across several communities while still keeping sensitive sources, collection methods, or national caveats protected. That is not a cosmetic requirement; it changes the service boundary.</p><p>The EU-first, NATO-second framing matters here because European and NATO interoperability often involves controlled sharing across sovereign and coalition boundaries. The system has to support collaboration without pretending that all participants have the same permissions. A useful architecture makes those differences explicit in labels, policy input, release paths, and evidence trails.</p><p>There is also a reliability angle. When a service cannot explain why a record was allowed, denied, redacted, or held for review, operators start compensating outside the system. The architecture then loses both control and usability.</p><h4><strong>Reference architecture</strong></h4><p>A label-aware service starts by separating four concerns that are too often mixed together. The first concern is identity: who or what is making the request, which organization or mission they belong to, and what attributes are asserted. The second concern is the data label: classification, compartments, releasability, caveats, source marking, provenance, and any handling restrictions that travel with the object. The third concern is policy: the rules that decide whether a subject may perform an action on the object in the current environment. The fourth concern is enforcement: the point in the service, gateway, workflow, or guard where the decision is applied.</p><p>The input layer should normalize subject and workload identity into attributes that policy can evaluate. That does not mean every service invents its own vocabulary. It means the platform needs a shared contract for facts such as organization, mission, clearance context, duty role, enclave, and session assurance.</p><p>The data layer should bind labels to objects before those objects move through APIs, event streams, search indexes, caches, and exports. If labels are attached only at the document repository, they will be lost when data becomes an event, a derived record, or a search result. A derived intelligence product may need to preserve the strongest label of its inputs, or it may need a deliberate downgrade workflow with human review.</p><p>The policy layer should be externalized enough to be reviewed and tested, but close enough to the runtime to make decisions with current context. A policy decision point can evaluate ABAC-style rules, label dominance, releasability, mission membership, environmental constraints, and exception paths. The enforcement point can live in the API, a sidecar, an API gateway, a data gateway, or a workflow step. The architecture should make the enforcement point visible, because invisible enforcement becomes inconsistent enforcement.</p><p>The guard and release layer is the controlled crossing point. It should be a small, observable capability that validates labels, applies release rules, records the decision input, and emits evidence. In some environments the guard may also redact fields or require human approval before data enters a mission partner environment.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KrM5li2CKs-Xcmn-t0aXBw.png" /></figure><p>The diagram shows the decision path as a first-class flow. Identity attributes and object labels both feed the policy decision point, while the service enforcement point and guard write to the audit log. The important choice is that the access decision is explicit, repeatable, and evidenced.</p><h4><strong>Technical view</strong></h4><p>At the runtime level, label-aware design changes the shape of the request. A normal service request might contain a user token, an action, and an object identifier. A label-aware request also needs the object label, environment attributes, and enough provenance to make the decision meaningful. The service should not fetch the object first and ask policy later if that leaks data through logs, traces, caches, or error messages.</p><p>For synchronous APIs, the enforcement point can run before the business function executes. It builds a policy input document from the subject, requested action, object label, and environment. The policy decision point returns permit, deny, redact, review, or step-up. Open Policy Agent is a useful open-source example because it separates policy decision-making from application code while still accepting structured input from the service.</p><p>For event-driven systems, the publisher must attach labels to the event envelope, not only the payload, so brokers, consumers, replay tools, and audit jobs can reason about the event before deserializing sensitive content. Consumers should enforce policy before processing. Replay pipelines need the same rule because old events may carry caveats that no longer match current release rules.</p><p>Caching deserves special attention. A cache that keys only on object ID can leak across compartments if the same record has different views for different subjects. Cache only after the enforcement point has produced a permitted view, and expire cached views when attributes, labels, or policy versions change.</p><h4><strong>Implementation pattern</strong></h4><p>A Python-based implementation is usually sufficient for explaining the decision shape. The example below is not a complete security model. It shows the architecture contract: the service collects subject attributes, object labels, environment context, and action, then produces a structured decision that can be enforced and audited.</p><pre>from dataclasses import dataclass<br>from enum import IntEnum<br>from typing import FrozenSet<br><br><br>class Level(IntEnum):<br>    public = 0<br>    restricted = 1<br>    confidential = 2<br>    secret = 3<br><br><br>@dataclass(frozen=True)<br>class Subject:<br>    user_id: str<br>    clearance: Level<br>    compartments: FrozenSet[str]<br>    mission: str<br>    organization: str<br><br><br>@dataclass(frozen=True)<br>class ObjectLabel:<br>    level: Level<br>    compartments: FrozenSet[str]<br>    releasable_to: FrozenSet[str]<br>    mission: str<br>    provenance_id: str<br><br><br>@dataclass(frozen=True)<br>class Decision:<br>    outcome: str<br>    reason: str<br>    audit_fields: dict[str, str]<br><br><br>def decide(subject: Subject, label: ObjectLabel, action: str) -&gt; Decision:<br>    if subject.clearance &lt; label.level:<br>        return deny(&quot;clearance below object level&quot;, subject, label, action)<br><br>    missing = label.compartments - subject.compartments<br>    if missing:<br>        return deny(f&quot;missing compartments: {&#39;,&#39;.join(sorted(missing))}&quot;, subject, label, action)<br><br>    if subject.mission != label.mission:<br>        return deny(&quot;mission mismatch&quot;, subject, label, action)<br><br>    if action == &quot;export&quot; and subject.organization not in label.releasable_to:<br>        return Decision(&quot;review&quot;, &quot;export requires release review&quot;, audit(subject, label, action))<br><br>    return Decision(&quot;permit&quot;, &quot;label policy satisfied&quot;, audit(subject, label, action))<br><br><br>def deny(reason: str, subject: Subject, label: ObjectLabel, action: str) -&gt; Decision:<br>    return Decision(&quot;deny&quot;, reason, audit(subject, label, action))<br><br><br>def audit(subject: Subject, label: ObjectLabel, action: str) -&gt; dict[str, str]:<br>    return {<br>        &quot;subject&quot;: subject.user_id,<br>        &quot;action&quot;: action,<br>        &quot;mission&quot;: label.mission,<br>        &quot;object_level&quot;: label.level.name,<br>        &quot;provenance_id&quot;: label.provenance_id,<br>    }</pre><p>The value of the sketch is not the code itself. The value is the boundary it makes visible. The service has no excuse to make an access decision from a role alone, and the audit record has the facts needed to reconstruct the decision later. A production implementation would add signed labels, policy versioning, trusted attribute sources, and tests for deny and review paths.</p><h4><strong>Failure modes and trade-offs</strong></h4><p>The first common failure mode is label drift. A source object has the correct label, but a derived record, search index, data product, or message loses part of that label. This is especially dangerous in intelligence fusion because derived data often feels less sensitive than raw input even when it inherits sensitive provenance. The mitigation is to define label propagation and transformation rules as part of the data contract.</p><p>The second failure mode is policy-invisible processing. A service receives clean business data but not the labels or attributes needed to decide correctly. The service then does something syntactically valid while violating the handling rule. Every path that reads, transforms, exports, caches, or replays compartmented data needs access to policy-relevant context.</p><p>The third failure mode is inconsistent enforcement. One API checks the policy engine, another relies on database roles, and a batch job has a local exception list. Each choice may have been practical locally, but together they create an audit problem and a bypass surface.</p><p>There are trade-offs. Strict enforcement can slow urgent sharing when attributes are incomplete. More granular labels improve precision but increase operational complexity. Externalized policy improves reviewability but introduces latency concerns. The answer is not to remove the policy layer. The answer is to design local policy bundles, review queues, and clear evidence for exceptions.</p><h4><strong>Technology mapping</strong></h4><p>The capability stack starts with identity and attributes. This can involve an enterprise identity provider, workload identity, certificate-based service identity, and a small attribute service that exposes only the facts needed for authorization. The policy decision capability can use Open Policy Agent, XACML-style infrastructure, or a purpose-built service.</p><p>Network segmentation remains important. Kubernetes NetworkPolicy, a service mesh using Envoy, and conventional firewalling can reduce unwanted lateral movement. They are containment controls, not data-label authorization. For durable state, PostgreSQL row-level security, database views, or application-side enforcement can help when they align with the same policy contract. In an Oracle-oriented estate, Oracle Database or Oracle Linux may fit into the platform, but the label-aware boundary should be defined above the product choice.</p><p>For audit and observability, OpenTelemetry, Prometheus, Grafana, and immutable log stores can provide useful building blocks. The important part is not the dashboard. The important part is that policy input, policy version, decision, enforcement point, and guard outcome are recorded in a way that supports later review.</p><h4><strong>Evidence and observability</strong></h4><p>A label-aware system should be able to prove more than uptime. It should prove that labels were present, policy was evaluated, enforcement occurred, guard decisions were recorded, and denied or review-needed paths were not silently dropped. The evidence model should include policy logs, label propagation checks, replay tests, guard release records, and synthetic transactions that verify deny behavior.</p><p>One useful practice is to test the negative path as a first-class operational signal. A synthetic subject without the required compartment should be denied. A record without a required label should be held for review. An export to a partner outside the releasability list should not leave the guard. These tests show that controls work under load, maintenance, and recovery.</p><p>Audit evidence should also include policy version and attribute freshness. Without those fields, a later investigation can show that a decision happened, but not whether it used the correct rule set.</p><h4><strong>Key takeaways</strong></h4><ul><li>Labels should be treated as runtime policy input, not decorative metadata.</li><li>Network segmentation helps containment, but it does not replace data-aware authorization.</li><li>The policy decision point, enforcement point, guard, and audit path should be explicit architecture components.</li><li>Derived data, caches, events, and exports need label propagation rules.</li><li>Deny and review paths deserve the same engineering attention as permit paths.</li></ul><p>The architecture principle is this: design compartmented services so that every sensitive action is decided from the subject, action, object label, environment, and policy version, then record the evidence. This protects more than confidentiality. It protects interoperability, auditability, and the trust needed for controlled sharing across EU, NATO, and allied mission environments.</p><h4><strong>About the author(s)</strong></h4><p>Johan Louwers is currently Chief Enterprise Architect for a large global tech company as well as the lead architect for NATO and a number of industrial, military &amp; governmental organisations. Johan has a strong and long background in the field of Enterprise Architecture and complex system engineering. Having worked with enterprises in a diverse set of industries as (enterprise) architect, CTO and technical and strategic business advisor Johan brings both deep technical knowledge to the table as well as strong business oriented expertise. In addition to this Johan is a tech addict who tends to enjoy supporting open source initiatives and actively coding as a hobby. Views expressed in this post are personnel and do not necessarily reflect the views of my current employer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5413f495620" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designing an Isolated Defence Cloud Without a Dead-End Platform]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://louwersj.medium.com/designing-an-isolated-defence-cloud-without-a-dead-end-platform-5fec56a3f170?source=rss-a68671a6ad8d------2"><img src="https://cdn-images-1.medium.com/max/1686/1*r4UukLhefDMdrtqrCenisw.png" width="1686"></a></p><p class="medium-feed-snippet">An isolated platform often looks excellent on the day it is accepted. The demo works, the control plane is reachable from the secure&#x2026;</p><p class="medium-feed-link"><a href="https://louwersj.medium.com/designing-an-isolated-defence-cloud-without-a-dead-end-platform-5fec56a3f170?source=rss-a68671a6ad8d------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://louwersj.medium.com/designing-an-isolated-defence-cloud-without-a-dead-end-platform-5fec56a3f170?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/5fec56a3f170</guid>
            <category><![CDATA[military]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Tue, 30 Jun 2026 13:29:26 GMT</pubDate>
            <atom:updated>2026-06-30T13:29:26.215Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Trust Starts Before the Operating System Boots]]></title>
            <link>https://louwersj.medium.com/trust-starts-before-the-operating-system-boots-883995d55f01?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/883995d55f01</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[defense]]></category>
            <category><![CDATA[defence]]></category>
            <category><![CDATA[military]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 08:46:38 GMT</pubDate>
            <atom:updated>2026-06-29T08:46:38.549Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Trust Starts Before the Operating System Boots — Johan Louwers" src="https://cdn-images-1.medium.com/max/1024/1*CWAt42c7d77WMhz-4NIEvw.png" /><figcaption>Trust Starts Before the Operating System Boots</figcaption></figure><p>A platform can pass every application health check and still be untrusted. The service may answer requests, the container may be running, and the dashboard may be green, but none of that proves the machine booted the software you intended to run. If firmware was changed, a bootloader was replaced, a kernel was tampered with, or a recovery image was silently rolled back, the application layer is already late to the conversation.</p><p>This is easy to forget because most architecture diagrams begin at the operating system. They show services, APIs, databases, message brokers, and observability pipelines. In sensitive infrastructure, disconnected edge sites, and EU or NATO-aligned mission environments, that is not enough. Trust starts before Linux starts. It starts in firmware, hardware roots of trust, signed boot paths, measured boot events, and evidence that can be verified later.</p><p>The practical lesson is simple: secure boot is not just a firmware setting. It is part of the architecture. A mission system should be able to prove what booted, decide whether that state is acceptable, and recover in a controlled way when the answer is no.</p><h4><strong>The architecture problem</strong></h4><p>Most teams treat boot security as a platform hardening topic. Someone enables UEFI Secure Boot, stores a few keys, checks a compliance box, and moves on to Kubernetes, APIs, or application controls. That work matters, but it only solves part of the problem. Secure Boot can help prevent unsigned boot components from loading, yet it does not by itself explain whether the complete platform state is expected, current, recoverable, and acceptable for a specific workload.</p><p>The important distinction is between enforcement and evidence. Secure Boot is primarily an enforcement mechanism: it checks signatures in the boot path and blocks components that are not trusted by policy. Measured boot is an evidence mechanism: it records measurements of boot components, often extending them into TPM Platform Configuration Registers, so another party can decide whether the state is known and acceptable. Attestation then turns that evidence into an architecture decision, usually by comparing measurements against policy before granting access, admitting a workload, or allowing a node into a mission enclave.</p><p>This is where the architecture starts to matter. A boot chain is not a single component. It includes firmware, firmware configuration, recovery images, bootloader, kernel, initramfs, kernel command line, integrity policy, device configuration, and sometimes early user-space agents. If any part is outside the evidence trail, the platform has a blind spot. If the evidence exists but no system evaluates it, the platform has a paper trail rather than a control.</p><h4><strong>Why this matters</strong></h4><p>In enterprise environments, a compromised boot path can turn a normal operational incident into a trust crisis. In defence environments, the problem becomes sharper because systems may run in field locations, secure enclaves, command-and-control support environments, or disconnected sites where central inspection is delayed. A military platform at the operational edge may need to keep working under constrained connectivity, but it should not silently accept a boot state that no longer matches policy.</p><p>For NATO-aligned mission architectures, this is also an interoperability issue. Coalition partners may share data, services, or infrastructure, but trust cannot be based only on organizational confidence. A mission partner environment needs technical evidence: what booted, which policy evaluated it, which workload was admitted, and what was recorded for audit. The common operating picture depends not only on data quality, but also on the trustworthiness of the systems producing and processing that data.</p><p>The issue is not that every node must be online at all costs. The issue is that a node must be understandable. If the platform boots into a degraded but known-good state, the operator can make a decision. If it boots into an unknown state and still joins the environment, the architecture has hidden risk inside normal operation.</p><h4><strong>Reference architecture</strong></h4><p>A useful reference architecture begins with a hardware root of trust and a small set of controlled firmware responsibilities. The firmware should verify the next stage, protect configuration that affects the boot path, and support a recovery route that is itself signed and governed. That recovery route matters because a system that can only fail closed may be secure in theory and unusable in operation. A system that can recover without evidence may be usable and untrusted.</p><p>The next layer is the bootloader and kernel path. UEFI Secure Boot can verify signed boot components before execution. Measured boot records what was loaded and how it was configured. The TPM provides a protected place to extend measurements so they cannot be casually rewritten after the fact. The operating system then continues the chain with integrity controls such as Linux IMA appraisal, package verification, signed kernel modules, and controlled runtime policy.</p><p>Above that sits the attestation and admission layer. The node produces evidence about its boot state. A verifier compares that evidence against an expected baseline for the platform role. If the state is acceptable, the node can receive secrets, join a cluster, start a workload, or connect to a sensitive API. If the state is not acceptable, the node enters a recovery or quarantine flow rather than pretending to be healthy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fCEslF_nvBic12knVb6x3g.png" /></figure><p>The diagram shows the key idea: the boot flow and the evidence flow are related but not identical. The platform moves from firmware to bootloader to kernel to runtime to workload, while measurements flow into a TPM-backed evidence path and then toward a verifier. The architecture decision happens when attestation evidence is evaluated before the workload is trusted with sensitive access.</p><h4><strong>Technical view</strong></h4><p>At the runtime level, the TPM is not a magic security box. It is a component that can protect keys, hold measurements, and support quotes over Platform Configuration Registers. The value comes from how the architecture uses it. A quote that nobody checks is just a signed artifact. A quote checked against stale policy can create false confidence. A quote tied to workload admission, secret release, and audit gives the platform an enforceable trust boundary.</p><p>Secure Boot and measured boot also solve different problems. Secure Boot asks, “is this component signed by a trusted authority?” Measured boot asks, “what actually happened during boot?” Both are useful. Secure Boot reduces the chance that unauthorized code runs early. Measured boot gives verifiers and auditors a way to reason about state after the boot sequence has happened.</p><p>Linux gives architects several useful building blocks here. The kernel, initramfs, kernel modules, and early user-space behavior can be brought into an integrity model. IMA can measure and appraise files according to policy, while tools such as `tpm2-tools` and projects such as Keylime can participate in TPM-based attestation workflows. The exact implementation will vary, but the architecture pattern is stable: measure early, verify before trust, and record enough evidence to explain the decision later.</p><h4><strong>Implementation pattern</strong></h4><p>For this article, Rust is a better teaching language than Python. A verifier could still be written in Python when it mainly orchestrates external TPM tooling and policy APIs. The deeper point here sits close to firmware, kernel state, and untrusted evidence from the operating edge. That is where Rust is useful: the code stays compact while making types and explicit failure states visible.</p><p>C would also be understandable in a firmware or kernel-interface discussion, but this verifier example does not require a C-first API. Rust is the better default because it keeps memory safety in the foreground. The verifier compares boot evidence with an approved baseline and returns an admission decision.</p><pre>#[derive(Debug)]<br>struct BootEvidence&lt;&#39;a&gt; {<br>    node_id: &amp;&#39;a str,<br>    pcr_digest: &amp;&#39;a str,<br>    ima_policy_hash: &amp;&#39;a str,<br>    kernel_version: &amp;&#39;a str,<br>    nonce: &amp;&#39;a str,<br>}<br><br>#[derive(Debug)]<br>struct ApprovedBaseline&lt;&#39;a&gt; {<br>    pcr_digest: &amp;&#39;a str,<br>    ima_policy_hash: &amp;&#39;a str,<br>    kernel_version: &amp;&#39;a str,<br>}<br><br>#[derive(Debug, PartialEq)]<br>enum TrustDecision {<br>    Accepted,<br>    Denied(&amp;&#39;static str),<br>}<br><br>fn approved_baseline(role: &amp;str) -&gt; Option&lt;ApprovedBaseline&lt;&#39;static&gt;&gt; {<br>    match role {<br>        &quot;edge-sensor-node&quot; =&gt; Some(ApprovedBaseline {<br>            pcr_digest: &quot;approved-pcr-digest&quot;,<br>            ima_policy_hash: &quot;approved-ima-policy&quot;,<br>            kernel_version: &quot;6.12.0-hardened&quot;,<br>        }),<br>        _ =&gt; None,<br>    }<br>}<br><br>fn evaluate_boot_state(role: &amp;str, evidence: &amp;BootEvidence) -&gt; TrustDecision {<br>    let baseline = match approved_baseline(role) {<br>        Some(value) =&gt; value,<br>        None =&gt; return TrustDecision::Denied(&quot;unknown platform role&quot;),<br>    };<br><br>    if evidence.pcr_digest != baseline.pcr_digest {<br>        return TrustDecision::Denied(&quot;PCR digest mismatch&quot;);<br>    }<br><br>    if evidence.ima_policy_hash != baseline.ima_policy_hash {<br>        return TrustDecision::Denied(&quot;IMA policy mismatch&quot;);<br>    }<br><br>    if evidence.kernel_version != baseline.kernel_version {<br>        return TrustDecision::Denied(&quot;kernel version mismatch&quot;);<br>    }<br><br>    TrustDecision::Accepted<br>}</pre><p>This example is deliberately small because the hard part is not the comparison logic. The hard part is lifecycle management around the baseline. Who approves a firmware update? How is the new measurement promoted from lab to field? How does a disconnected node prove its state when the verifier is temporarily unreachable? What happens when a valid node must boot into a signed recovery image that has different measurements? Those are architecture questions, not just implementation details.</p><p>In a practical design, the verifier decision should feed a clear control point. It might release short-lived credentials, allow the node to join a Kubernetes cluster, enable access to a message broker, or permit a workload to read mission data. If the decision fails, the node should still produce telemetry and recovery evidence, but it should not receive the same trust as a known-good platform.</p><h4><strong>Failure modes and trade-offs</strong></h4><p>The first failure mode is the false sense of security that comes from enabling only one control. Secure Boot can block unsigned components, but it does not remove the need for measured evidence. Measured boot can record state, but it does not automatically stop a bad state from being used. Attestation can make a decision, but only if the policy is current and connected to an actual access boundary.</p><p>The second failure mode is recovery without governance. Field systems need recovery routes, especially in disconnected or degraded conditions. A recovery image can be essential for readiness, but it also changes the boot state. If the architecture treats recovery as an exception outside the trust model, it creates a gap exactly when operators are under pressure.</p><p>The third failure mode is stale baselines. Firmware, bootloaders, kernels, and integrity policies change over time. If the baseline process is slow, teams may bypass it. If the process is too loose, the verifier becomes ceremonial. The architecture has to support controlled promotion from lab validation to operational approval, with rollback rules and audit trails.</p><p>There are trade-offs. Strict attestation can improve trust but reduce availability when connectivity to the verifier is lost. Local cached decisions can preserve operation but may extend trust longer than intended. Signed recovery images improve resilience but increase the number of acceptable states the policy must manage. The answer is rarely one global rule. The answer is to make trust states explicit: approved, degraded, recovery, quarantine, and unknown.</p><h4><strong>Technology mapping</strong></h4><p>The capability map should start with functions rather than products. Firmware verification belongs near UEFI Secure Boot or equivalent platform controls. Evidence capture belongs near TPM-backed measured boot, event logs, and integrity measurement. Runtime policy belongs near Linux integrity controls, signed modules, package verification, and workload admission. Verification belongs near an attestation service, policy store, and audit trail.</p><p>Open-source tooling can be very useful in this space. Linux, `tpm2-tools`, Keylime, OpenTelemetry, and Kubernetes admission patterns can all play a role, depending on whether the platform is a bare-metal edge node, a private cloud cluster, or an embedded system-on-board device. In an Oracle-oriented environment, Oracle Linux could be part of the hardened operating-system layer, but the architecture should remain described in capability terms rather than tied to that choice.</p><p>The portability point is important. A good trust-chain architecture should survive a change in hardware vendor, Linux distribution, private cloud platform, or attestation implementation. What should remain stable is the boundary: no sensitive workload, credential, or mission data access should depend only on application health. It should depend on platform trust evidence as well.</p><h4><strong>Evidence and observability</strong></h4><p>Evidence should be designed before the incident. The system should record firmware versions, bootloader identity, kernel version, kernel command line, IMA policy hash, attestation result, verifier policy version, workload admission decision, and recovery state. These records should be queryable later, because the question after an incident is rarely “was the service up?” The question is “what was trusted, by whom, under which policy, and with what evidence?”</p><p>Observability also needs to distinguish between operational health and trust health. A node can be alive but quarantined. A workload can be ready but waiting for attestation. A verifier can be reachable but rejecting nodes because a baseline changed. These are not generic errors. They are architecture signals and should appear in logs, metrics, and operational dashboards.</p><p>For disconnected environments, the evidence model needs local durability. If a node cannot reach the verifier, it should retain signed evidence and decision history until synchronization is possible. The goal is not to pretend connectivity exists. The goal is to preserve a trustworthy chain of events so the platform can recover, synchronize, and be audited later.</p><h4><strong>Key takeaways</strong></h4><ul><li>Secure Boot is useful, but it is not the whole trust architecture.</li><li>Measured boot and TPM-backed evidence make platform state visible after boot.</li><li>Attestation becomes powerful when it is connected to workload admission, credential release, and audit.</li><li>Recovery images must be signed, governed, measured, and observable.</li><li>Trust health should be monitored separately from application health.</li></ul><p>The architecture principle is this: do not start the trust model at the application boundary. Start it at firmware, carry it through the boot path, measure the state that matters, and use that evidence before granting access to sensitive workloads or data. That protects operational confidence, because it lets the platform distinguish between a healthy service and a trustworthy system.</p><h4><strong>About the author(s)</strong></h4><p>Johan Louwers is currently Chief Enterprise Architect for a large global tech company as well as the lead architect for NATO and a number of industrial, military &amp; governmental organisations. Johan has a strong and long background in the field of Enterprise Architecture and complex system engineering. Having worked with enterprises in a diverse set of industries as (enterprise) architect, CTO and technical and strategic business advisor Johan brings both deep technical knowledge to the table as well as strong business oriented expertise. In addition to this Johan is a tech addict who tends to enjoy supporting open source initiatives and actively coding as a hobby. Views expressed in this post are personnel and do not necessarily reflect the views of my current employer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=883995d55f01" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Event Schemas as the Contract of a Mission Platform]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://louwersj.medium.com/event-schemas-as-the-contract-of-a-mission-platform-e2d360eae75c?source=rss-a68671a6ad8d------2"><img src="https://cdn-images-1.medium.com/max/1693/1*kOptGRJWkpyv_2awxXR4Bg.png" width="1693"></a></p><p class="medium-feed-snippet">A sensor service changes a field name, an analytics job assumes the old format, and an operator display stops showing one class of update&#x2026;</p><p class="medium-feed-link"><a href="https://louwersj.medium.com/event-schemas-as-the-contract-of-a-mission-platform-e2d360eae75c?source=rss-a68671a6ad8d------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://louwersj.medium.com/event-schemas-as-the-contract-of-a-mission-platform-e2d360eae75c?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/e2d360eae75c</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[event-driven-architecture]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[military]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 06:16:00 GMT</pubDate>
            <atom:updated>2026-06-29T06:16:00.734Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Designing a Mission Event Backbone With Replay and Auditability]]></title>
            <link>https://louwersj.medium.com/designing-a-mission-event-backbone-with-replay-and-auditability-1b423e3e93de?source=rss-a68671a6ad8d------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b423e3e93de</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[military]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Johan Louwers]]></dc:creator>
            <pubDate>Sun, 28 Jun 2026 08:01:02 GMT</pubDate>
            <atom:updated>2026-06-28T08:01:02.720Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*txcM6EPZxsIsFQpy1r5j4A.png" /><figcaption><strong>Designing a Mission Event Backbone With Replay and Auditability</strong></figcaption></figure><p>A sensor feed arrives late, an intelligence update is corrected after review, and a decision-support service restarts halfway through a shift. Services are green and containers are running, yet nobody can explain which events were seen, which were missed, which were replayed, and which decision views were built from which version of the facts.</p><p>That is where event-driven architecture becomes more than an integration pattern. In a mission environment, the event backbone is not a message bus between services. It becomes part of the operational memory of the platform when services, sensors, analytics, and operator workflows are distributed across edge nodes, secure enclaves, central services, and mission partner environments.</p><p>The practical lesson is simple: if replay and auditability are added later, they become fragile. If they are designed into the event backbone from the beginning, they become operating capabilities. The issue is not only whether an event was delivered. The issue is whether the platform can prove what happened, recover the right processing state, and explain the evidence chain when the system is reviewed later.</p><p>This article looks at a mission event backbone as an architecture problem, not as a product selection exercise. Kafka, NATS JetStream, OpenTelemetry, PostgreSQL, and similar technologies can all play useful roles, but the important design choice sits above any one product. The backbone needs a clear contract for append, retention, replay, ordering, idempotency, provenance, and operational control.</p><h4><strong>The architecture problem</strong></h4><p>Event-driven systems are often introduced to decouple services. One service publishes an event, another service consumes it, and the two no longer need to call each other synchronously. That is useful, but it is only the first-order benefit. The harder architecture question is what happens when events become the record of operational reality.</p><p>In a defence platform, event streams may represent sensor observations, operator actions, system-health signals, logistics updates, intelligence assessments, access-control decisions, or changes to a common operating picture. Each event may be small, but the sequence matters. If the platform loses the order, drops the provenance, or replays events without control, the downstream view can become technically available but operationally misleading.</p><p>The event backbone therefore has to handle more than transport. It has to separate raw ingestion from accepted events. It has to make validation explicit. It has to store enough history for controlled replay. It has to expose audit trails without forcing every consumer to become its own forensic system. It also has to tolerate the normal ugliness of mission systems: intermittent links, late data, duplicate messages, partial outages, and services that recover at different speeds.</p><p>The failure mode is easy to miss. Teams often build a fast publish-subscribe layer and then ask individual services to handle replay, deduplication, and audit locally. That works while the number of consumers is small. It fails when the platform grows, because every local interpretation of “what happened” starts to drift from every other interpretation.</p><h4><strong>Why this matters</strong></h4><p>EU and NATO-aligned mission environments are built around interoperability, controlled sharing, and operational continuity under imperfect conditions. A military system may need to exchange information across national, coalition, and organizational boundaries while still preserving local control and need-to-know access. That does not mean every event can be shared everywhere. It means the architecture must know which events exist and which policies apply.</p><p>For command-and-control and decision-support workflows, the event backbone becomes a trust boundary as much as a data path. The platform needs to support operators who are working with incomplete information, changing context, and degraded connectivity. If a service reconnects after an outage, replay should help it catch up. Replay should not accidentally create duplicate alerts, overwrite newer context with older data, or hide the fact that a delayed event arrived after a decision was already made.</p><p>This also matters outside traditional defence settings. Once events drive decisions, the event history becomes evidence, and the architecture should make that evidence available, interpretable, and bounded by policy.</p><h4><strong>Reference architecture</strong></h4><p>A good mission event backbone starts with a simple separation of responsibilities. The source layer produces events from sensors, applications, operator workflows, and platform telemetry. The ingestion layer receives those events and adds a consistent envelope: source identifier, event type, timestamp, correlation identifier, schema version, classification or handling marker, and trace context where appropriate.</p><p>The validation and policy layer decides whether an event can enter the accepted stream. This is where schema validation, authorization, source marking, and basic semantic checks belong. Rejected events should not disappear. They should be quarantined with enough context for troubleshooting, because a rejected event may indicate a broken producer, a policy mismatch, or a real change in the field that the platform does not yet understand.</p><p>The durable event backbone is the center of the design. It stores accepted events in append-only streams with defined retention, ordering expectations, and replay rules. Technologies such as Apache Kafka and NATS JetStream show the core pattern clearly: producers append to named streams or topics, consumers track progress, and the system retains events long enough for recovery, audit, or reprocessing.</p><p>Around the backbone sit stream processors, decision services, analytics jobs, audit stores, provenance indexes, and observability systems. Some consumers act immediately, such as alerting or enrichment services. Others build materialized views, such as a current operational picture. Others exist for control and assurance: replay controllers, audit queries, dead-letter workflows, and evidence review.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0l7jkqV7EMpuWFWBATXwvg.png" /></figure><p>The diagram shows the distinction that matters most: ingestion does not write directly into every consumer. Events first pass through schema and policy checks, then enter a durable backbone that can feed processors, decision services, audit stores, and controlled replay. This keeps replay from becoming a hidden side effect inside each application.</p><h4><strong>Runtime view</strong></h4><p>At the runtime level, the backbone should treat event acceptance as a deliberate transition. A raw message is not yet an accepted mission event. It becomes one only after the platform has attached the right metadata, validated the payload, applied policy, and written it durably.</p><p>Ordering is often misunderstood. Global ordering sounds attractive, but it is expensive and usually unnecessary. Most mission systems need ordering within a meaningful stream: one sensor, one track, one case, one asset, one workflow, or one mission thread. The architecture should document where ordering matters and where it does not. That choice affects partitioning, consumer scaling, replay speed, and how conflicts are resolved later.</p><p>Replay is also not a single feature. There is recovery replay, where a consumer catches up after being offline. There is analytical replay, where a team reprocesses historical events through a new model or rule set. There is forensic replay, where auditors reconstruct what a user or service could have known at a specific time. These modes have different controls. A recovery replay may be automatic. A forensic replay may require approval, immutable logs, and a documented reason.</p><p>Observability needs to follow the event across those modes. OpenTelemetry is useful here because trace context, logs, and metrics can be connected across services. A trace identifier in the event envelope does not replace an audit trail, but it helps operators connect runtime behavior to event flow. The audit trail answers “what was accepted and used?” Observability helps answer “where did it slow down, fail, or branch?”</p><h4><strong>Implementation pattern</strong></h4><p>A Python-based implementation can make the event boundary explicit without tying the architecture to one broker. The important idea is to validate, assign identifiers, append durably, and return an acknowledgement only after the accepted event is safely written.</p><pre>from datetime import datetime, timezone<br>from hashlib import sha256<br>from uuid import uuid4<br><br><br>def build_event(raw: dict, source: str, handling_mark: str) -&gt; dict:<br>    payload = raw[&quot;payload&quot;]<br>    return {<br>        &quot;event_id&quot;: str(uuid4()),<br>        &quot;event_type&quot;: raw[&quot;type&quot;],<br>        &quot;source&quot;: source,<br>        &quot;schema_version&quot;: raw[&quot;schema_version&quot;],<br>        &quot;observed_at&quot;: raw[&quot;observed_at&quot;],<br>        &quot;accepted_at&quot;: datetime.now(timezone.utc).isoformat(),<br>        &quot;correlation_id&quot;: raw.get(&quot;correlation_id&quot;, str(uuid4())),<br>        &quot;handling_mark&quot;: handling_mark,<br>        &quot;payload_hash&quot;: sha256(repr(sorted(payload.items())).encode()).hexdigest(),<br>        &quot;payload&quot;: payload,<br>    }<br><br><br>async def accept_event(raw: dict, source: str, policy, schema_validator, event_log):<br>    schema_validator.validate(raw[&quot;type&quot;], raw[&quot;schema_version&quot;], raw[&quot;payload&quot;])<br>    handling_mark = policy.handling_mark_for(source, raw)<br>    event = build_event(raw, source, handling_mark)<br><br>    stream_name = f&quot;{event[&#39;event_type&#39;]}.{event[&#39;source&#39;]}&quot;<br>    await event_log.append(stream_name, event[&quot;event_id&quot;], event)<br>    return {&quot;accepted&quot;: True, &quot;event_id&quot;: event[&quot;event_id&quot;]}</pre><p>The sketch hides the broker-specific details behind `event_log.append`. In a NATS JetStream implementation that may publish to a stream with durable consumers. In a Kafka implementation it may write to a topic with defined retention and consumer groups. In both cases, the application boundary remains the same: validate first, append durably, then acknowledge.</p><p>The event identifier is not only for deduplication. It is also for evidence. If a later service enriches the event, emits a derived event, or updates a materialized view, it should preserve the original event identifier or correlation chain. That is how the platform later explains which input contributed to which outcome.</p><h4><strong>Failure modes and trade-offs</strong></h4><p>Network partitions are the obvious failure mode, but they are not the only one. Under degraded connectivity, an edge node may continue to accept local events while central consumers are unreachable. That is valid only if the local node has a durable buffer, clear retention limits, and a synchronization rule that can handle late arrival. The platform should not pretend that delayed events are fresh events.</p><p>Duplication is another normal condition. Producers retry, brokers redeliver, consumers restart, and replay intentionally sends old events through new paths. Consumers should be idempotent where possible, which means applying the same event twice should not create two operational effects. Idempotency usually requires a stable event identifier, a consumer-side processed-event record, and careful treatment of side effects such as notifications.</p><p>Replay storms are a quieter risk. If several consumers restart and all request large historical replays at once, the backbone can spend its capacity serving the past while live processing waits. The architecture should include replay rate limits, priorities, and operator visibility. Recovery is important, but uncontrolled recovery can become its own incident.</p><p>There is also a storage trade-off. Longer retention improves replay, audit, and analytical reprocessing, but it increases cost and governance burden. Not every stream needs the same retention period. A system-health heartbeat may need days. A decision event or source-marked intelligence update may need far longer, depending on policy and legal constraints.</p><p>Finally, strict validation can reject events during a real operational change. Loose validation can let polluted data enter the backbone. The practical design choice is to validate the envelope strictly, validate the payload against a versioned schema, and provide a controlled quarantine path for exceptions. This preserves the main stream without hiding the exception.</p><h4><strong>Technology mapping</strong></h4><p>The core capability is a durable event log with controlled consumption and replay. Apache Kafka is a common open-source choice when teams need partitioned topics, high-throughput streams, long retention, and mature ecosystem tooling. NATS JetStream is attractive where lightweight deployment, simple operations, and stream persistence are important, especially for edge or smaller private-cloud footprints.</p><p>Schema and event-envelope standards sit beside the broker. CloudEvents provides a common event metadata shape, while AsyncAPI can document event-driven interfaces in a way that producers and consumers can review. PostgreSQL can be useful for audit projections, replay request records, and consumer state, while OpenTelemetry helps connect event flow to traces, metrics, and logs.</p><p>The deployment runtime should remain portable. Linux, Kubernetes, container registries, and GitOps workflows can support repeatable environments from central platforms to operational edge nodes. In an Oracle-oriented environment, Oracle Linux or Oracle Database could play a role for runtime and audit storage, but the architecture should not depend on that product choice.</p><p>The important distinction is capability before product. A mission event backbone needs append, retention, replay, schema control, consumer progress, policy enforcement, and observability. Once those capabilities are explicit, the platform can map them to products without letting a product silently define the architecture.</p><h4><strong>Evidence and observability</strong></h4><p>An event backbone is trustworthy only if it can show its work. The minimum evidence set includes accepted-event records, rejected-event records, consumer offsets or sequence positions, replay requests, schema versions, policy decisions, and operator actions that changed replay or retention behavior. Without that, the platform may be processing events correctly while still being unable to prove it.</p><p>Operational metrics should include ingest rate, acceptance rate, rejection rate, consumer lag, replay volume, dead-letter volume, stream storage, retention pressure, and end-to-end processing latency. These metrics should be sliced by stream and consumer group, because an average across the whole platform hides the failure mode that matters. One consumer can be far behind while the rest of the system looks healthy.</p><p>Audit evidence should be immutable enough for review, but usable enough for engineers and operators. A write-once log that nobody can query under pressure is not operationally helpful. A dashboard without the underlying event trail is not enough either. The architecture needs both: human-readable evidence and machine-readable history.</p><p>Testing should exercise replay as a normal behavior, not as a rare disaster procedure. Teams should test cold consumer recovery, duplicate delivery, late-arriving events, schema rejection, quarantine handling, replay throttling, and rebuild of a materialized view from history. If the platform cannot rebuild its view in a controlled test, it will not do so cleanly during a real incident.</p><h4><strong>Key takeaways</strong></h4><ul><li>Treat the event backbone as operational memory, not just integration plumbing.</li><li>Validate and mark events before they enter the accepted stream.</li><li>Design replay as a controlled capability with evidence, limits, and ownership.</li><li>Keep broker selection separate from the architecture capabilities the mission needs.</li></ul><p>The architecture principle is this: a mission platform should be able to explain its own event history. Architects should design the backbone so that accepted events, rejected events, replay decisions, and consumer progress are visible and auditable from the start. That protects recovery, trust, and operational continuity when the system is no longer on the happy path.</p><h4><strong>About the author(s)</strong></h4><p>Johan Louwers is currently Chief Enterprise Architect for a large global tech company as well as the lead architect for NATO and a number of industrial, military &amp; governmental organisations. Johan has a strong and long background in the field of Enterprise Architecture and complex system engineering. Having worked with enterprises in a diverse set of industries as (enterprise) architect, CTO and technical and strategic business advisor Johan brings both deep technical knowledge to the table as well as strong business oriented expertise. In addition to this Johan is a tech addict who tends to enjoy supporting open source initiatives and actively coding as a hobby. Views expressed in this post are personnel and do not necessarily reflect the views of my current employer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b423e3e93de" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>