Skip to content
Zakaria Ait Ali

DevOps & Cloud Engineer

DevOps, cloud, and the systems behind software.

I’m Zakaria, a DevOps and Cloud Engineer. I work on the part of software most people never see: the pipelines, infrastructure and runtime that take a change from commit to a reliable, observable service. This domain is where I build and document that work over time.

Explore the siteView CV
An ink-wash mountain range with a dotted route climbing from fundamentals, through automation and platforms, to reliable systems at the summit.

The bigger picture

A DevOps map

How a change travels from code to a running, observable system, and how what we learn flows back. A simplification, drawn as a loop, because operating software never really finishes.

Automation runs through every stage: make it repeatable.

  1. 01Develop

    Change starts as code under version control.

    • Git
    • Linux
    • Programming
    • Scripting

  2. 02Build

    Code becomes something that can run.

    • Dependencies
    • Tests
    • Artifact creation

  3. 03CI/CD

    Every change goes through the same automated path.

    • Automation
    • Security checks
    • Delivery workflows

  4. 04Artifact

    One immutable, versioned output per release.

    • Container images
    • Registries
    • Versioning

  5. 05Deploy

    Declared state, applied to an environment.

    • Containers
    • Kubernetes
    • Infrastructure as Code
    • GitOps

  6. 06Run

    The service lives on real infrastructure.

    • Cloud
    • Networking
    • Scaling
    • Runtime security

  7. 07Observe

    The system explains what it is doing.

    • Metrics
    • Logs
    • Traces
    • Alerts

  8. 08Improve

    What was learned flows back into the next change.

    • Reliability
    • Performance
    • Cost
    • Feedback

Feedback returns to Develop: learn, and make it better.

Twelve-factor thinking

Principles for modern software

The Twelve-Factor App is a long-standing foundation for portable, automatable software. Its principles shape how I design, build and run systems.

  1. Factor 1: Codebase

    One codebase in version control, many deploys.

  2. Factor 2: Dependencies

    Declare them explicitly; isolate them.

  3. Factor 3: Config

    Keep configuration in the environment, not the code.

  4. Factor 4: Backing services

    Databases and queues are attached resources.

  5. Factor 5: Build, release, run

    Three stages, kept strictly apart.

  6. Factor 6: Processes

    Run as stateless processes; state lives elsewhere.

  7. Factor 7: Port binding

    A service exports itself over a port.

  8. Factor 8: Concurrency

    Scale out by adding processes.

  9. Factor 9: Disposability

    Start fast, shut down gracefully.

  10. Factor 10: Dev/prod parity

    Keep every environment as alike as possible.

  11. Factor 11: Logs

    Treat logs as event streams.

  12. Factor 12: Admin processes

    One-off tasks run in the same environment.

Built under this domain

A home for apps, notes and experiments

This domain will grow with my work: apps, small infrastructure labs, and notes on what I learn. Nothing is published yet; when something ships, it will be linked here.

  • Apps

    Coming later

    Things I build and run myself, each eventually on its own subdomain.

  • Labs

    Coming later

    Small infrastructure experiments: a pipeline, a cluster, a failure on purpose.

  • Notes

    Coming later

    Technical writing that documents what I learn while doing the work.