Aland Azad — DevSecOps Engineer, Kurdistan Region, Iraq

I follow systems all the way down.

I build Kubernetes platforms, write the Helm charts and pipelines teams ship with, and turn what I learn into rules that people, and coding agents, can follow.

Simple first. Secure by default. Verified, not assumed.

I Application II Delivery III Platform IV Infrastructure V Network Fig. 1 — The stack, in section

Layer I · The work

Four things I keep building.

Most of my work is the layer under someone else’s work. When I do it well, nobody thinks about it.

  1. Platform engineering

    Clusters I can rebuild, not repair

    Talos for the operating system, Pulumi for provisioning, kind for the lab. Cilium, Traefik, cert-manager, Kyverno and CloudNativePG on top. Every layer is declared in code, so a broken cluster is a rebuild, not an archaeology project.

    Make the common path safe and boring.

    Talos · Pulumi · Cilium · Traefik

    Read the case study
  2. Delivery

    Five charts, one way to ship

    I maintain a small set of Helm charts: workload, job, edge and mariadb, all on one shared library. Reusable GitHub workflows test, package, push and sign them. Flux reconciles everything from three repositories: central, infrastructure and applications.

    Change goes through Git. Controllers do the rest.

    Helm 4 · Flux · GitHub Actions

    Read the field note
  3. Supply chain

    Pinned, signed, or it doesn’t run

    Images pinned by tag and digest, scanned with Trivy, signed keylessly with Cosign through GitHub’s OIDC token, and verified by Kyverno before a pod starts. Containers run as UID 10001 on a read-only filesystem with every capability dropped.

    Turning safety off takes an explicit setting. Turning it on never does.

    Cosign · Trivy · Kyverno · SBOM

    Read the field note
  4. Standards as code

    Rules for people and agents

    My engineering standards live in one repository: 34 skills, every rule with a code like K8S-006. Coding agents load them before they touch a project and cite the code when they break a rule. They write; I review, commit, push and deploy.

    If I correct the same mistake twice, it becomes a rule or a check.

    AGENTS.md · Agent Skills · Claude Code

    See the rules I keep

Layer II · Borehole log

What I reach for, layer by layer.

From source code to the packet leaving the edge. Failures don’t respect team boundaries, so I try not to either.

Field rule DNS before deployment YAML. Routes before controllers. Certificates before annotations.

The toolkit, layer by layer
Depth Layer Toolkit Approach
Application TypeScript on Bun · Python with uv · Go · .NET · Rust · Java Build
Delivery GitHub Actions · Flux · Helm 4 · Kustomize · GitLab CI Ship
Security Cosign · Trivy · Grype · Kyverno · Sealed Secrets · OpenBao · PKI Harden
Platform Kubernetes · Talos · Cilium · Traefik v3 · cert-manager · CloudNativePG Operate
Infrastructure Pulumi · OpenTofu · Cloudflare · AWS · Linux · mise Provision
Network DNS · TLS · WireGuard · NetBird · nftables · routing · NAT Trace

Layer III · Principle

When something behaves strangely, fix it. Don’t document the surprise.

It’s rule six of eight I keep. The interesting work sits at the seams: a deploy that turns out to be a DNS problem, a security control that turns out to be a developer-experience problem. I follow it down until the cause has a name, then fix that. All eight rules

Four steps, every time.

  1. Research. Primary sources first: the spec, the release notes, the source code. Write down what I don’t know yet.
  2. Build. The smallest version that works. Every option has to earn its place, or it goes.
  3. Break. Write the check that fails first. Then follow the packet, the trust chain or the reconcile loop until it passes.
  4. Standardize. Keep what survived: a chart, a workflow, or a rule with a code. If I fixed it twice, it becomes a check.
On my radar
  • Platform engineering
  • Software supply-chain security
  • GitOps & delivery systems
  • Standards for coding agents
  • Distributed systems
  • Infrastructure security

Layer IV · Field notes

From the workbench.

Each note starts with a symptom and ends at the cause, usually one layer lower than it first looked.

All 6 field notes
  1. PKI-009

    Building trust from the root up

    PKI becomes easier to reason about when it is treated as trust-chain and lifecycle design, not as a sequence of certificate-generation commands.

    • OpenSSL
    • X.509
    • CRL
    • TLS
    2 min read
  2. K8S-031

    Delivery as reconciliation

    GitOps is most useful when desired state, reconciliation order, and ownership boundaries are explicit enough to operate under failure.

    • FluxCD
    • Helm
    • Kustomize
    • GitOps
    2 min read
  3. EDGE-012

    Ingress is a routing problem

    Ingress failures become tractable when DNS, TLS, edge reachability, controller routing, service discovery, and workload health are tested as one path.

    • Gateway API
    • Istio
    • Traefik
    • DNS
    2 min read
  4. CI-024

    One pipeline primitive, many languages

    Reusable CI should standardize security and delivery behavior across languages while leaving language-specific build logic explicit.

    • CI/CD
    • Reusable workflows
    • Supply chain
    2 min read
  5. OPS-044

    Restore is not recovery until the cluster agrees

    Restoring etcd data is one step in Kubernetes recovery; control-plane identity, manifests, endpoints, certificates, and reconciliation still have to agree.

    • etcd
    • Kubernetes
    • Recovery
    2 min read

Layer V · Path

How I got down here.

Software engineering first. Then automation, where I learned that most slow processes are systems with people inside them. Now platforms, where both meet.

Read it like any section through rock: the newest layer sits on top.

More about me
  1. 2026 → now

    DevSecOps Engineer

    Kurdistan Region Government · DIT

    Platform engineering, GitOps, CI/CD, Kubernetes operations and security. Most of the job is making the safe path the easy one, then writing it down so the next team doesn’t solve the same problem again.

    Current layer
  2. 2025 → 2026

    Process Excellence & Automation Expert

    Asiacell Communications

    Automation across technology, finance, procurement, cybersecurity and operations. It taught me to connect technical decisions with the people, processes and controls around them, and that a fix nobody adopts isn’t a fix.

  3. 2024

    B.Sc. Software Engineering

    American University of Iraq, Sulaimani

    The bedrock: software engineering, networking, distributed systems, computing platforms and design patterns. Where I learned to read the layer below the one that’s failing.

Certified

Tap one for the specimen sheet: what it tests, how it’s weighted, and where it shows up in my work.