Skills
All skills
The full list, sorted by domain then by block. Search, filter by job, course, certification or status, and open a skill: it tells what you need to know first, who asks for it, and the path you have left.
Browse the listBack to the skills home
- 434 skills follows the list filters
- 24 domains from the base to security
- 7 jobs offered as a list filter
- 53 courses that teach them
- 7 certifications they help prepare
How to read this catalog A skill, its status for you, its prerequisites: what each line tells you.
Skill, status, prerequisites
The catalog lists know-how, not courses, sorted by domain then by block. Each line gives the workload and the ways to validate it; the skill page gives the rest.
A skill
Not a course
A skill describes what you will be able to do, and several courses can lead to it. Its page says which ones and, when a tool can be chosen, your preferences decide the path followed in your journey.
A status
Computed for you
Acquired when its quizzes are passed or its proof lab is passed, in progress once you have started, ready when its prerequisites are in place, locked while a foundation is missing. The computation happens in your browser, from what you have read and passed (quizzes, labs).
Prerequisites
And a path
Each skill knows what you need to know first. Its page draws the path, from the most upstream foundation to the skill, with the time you have left. Adding it to your goals brings it into your journey, prerequisites included, without removing anything you already aim for.
Catalog
All skills
One line per skill: its workload, its ways of validation and, once you have started, your status. Collapse a domain, or filter: sections without results disappear.
Linux
40
Use a terminal 1
Work on a Linux system 6
- Find your way around the tree and handle files and text from the command line
- Install a Linux system and identify its distribution
- Install and maintain software
- Manage users, permissions and processes
- Troubleshoot the network and read the logs
- Use Bash efficiently: variables, expansions and a first script
Run a Linux server 2
Administer a Linux server 8
- Automate in the shell and schedule tasks
- Configure and troubleshoot a server's network
- Maintain a server's software and monitor its resources
- Manage logical volumes, software RAID and disk encryption
- Monitor processes and performance
- Mount network storage: NFS, SMB and iSCSI
- Prepare local storage: disks, partitions, file systems and mounting
- Troubleshoot a Linux server
Secure a Linux system 3
Process text and files on the command line 5
- Back up and restore a directory tree with tar
- Build a pipeline that extracts, sorts, counts, compares and follows a text stream
- Download a file and check its integrity and authenticity
- Edit a configuration file in Vim: modes, motions, substitution
- Transform files and streams with sed, awk and regular expressions
Customize your working environment 2
Manage packages and reproducible environments with Nix 2
Isolate and limit processes with the kernel 1
Trace and harden the kernel with eBPF 2
Harden a Linux server against a baseline 8
- Confine a service: mandatory access control (SELinux or AppArmor), then systemd sandboxing
- Harden a NixOS server declaratively: versioned measures, test before switching, runtime checks and rollback to a healthy generation
- Harden a server's access and privileges: SSH, PAM, sudo, permissions and scheduling
- Harden boot, mounts and the local session: GRUB, nodev, nosuid, noexec, banners, dconf
- Harden the running kernel: persistent sysctl parameters and blocked modules
- Measure a server's gap to a hardening baseline and prioritize the measures (ANSSI-BP-028, CIS)
- Rebuild a KSPP-hardened kernel and prove its options at boot
- Trace who did what on a Linux server with auditd: persistent rules, ausearch and aureport
Networking
16
Understand and observe an IP network 5
Operate and troubleshoot network services 5
Troubleshoot application protocols 2
Segment, filter and encrypt 4
Architecture
6
Read and analyze a services architecture 6
- Analyze an architecture's entry point: proxies, load balancing and edge
- Assess how an architecture is operated: recovery, admin access, detection and impact
- Classify an architecture's data and decide what to back up or replicate
- Follow an architecture's asynchronous exchanges and predict their failures
- Identify an architecture's cross-cutting dependencies and trust boundaries
- Read an architecture diagram: role, flows, state and dependencies of each component
Operations
7
Keep a fleet in operational condition 6
Understand the job 1
Observability
7
Observe a service and its platform 7
- Build a dashboard that answers an operations question
- Centralize a service's logs and query them
- Collect a service's metrics and check their quality
- Define an actionable alert and route it without noise
- Instrument a service so it emits useful telemetry
- Query a service's metrics to answer an operations question
- Route telemetry through a collection pipeline
Git
9
Collaborate with Git 4
Repair and investigate the history 2
Host and assemble Git repositories 3
Scripting
17
Automate with code 2
Industrialize a Python or Go project 4
Master the Python language 5
- Design Python classes: encapsulation, inheritance, abc and mixins
- Manipulate lists, tuples, sets and slices in Python
- Model and type data in Python with dataclasses, Enum and annotations
- Process and generate text in Python: strings, regex, dates and Jinja templates
- Write idiomatic Python: decorators, generators, context managers and itertools
Build applications and automate with Python 4
Write the basics of a Go program 2
Containers
11
Build and run containers 5
Containerize without a daemon or root with Podman 3
Understand what isolates a container 3
Kubernetes
50
Deliver an application on Kubernetes 8
- Adapt manifests per environment with Kustomize
- Change Kubernetes resources declaratively without drifting from Git
- Configure an application with ConfigMaps and Secrets
- Configure kubectl access to your clusters: kubeconfig, contexts and default namespace
- Deploy and observe an application on Kubernetes
- Expose an application with a Service, Ingress or Gateway
- Isolate traffic between Pods with NetworkPolicies
- Update an application and roll back
Design Kubernetes workloads 8
- Compose a multi-container Pod: init, sidecar, shared volumes
- Deploy a stateful application (StatefulSet)
- Keep an application available during disruptions
- Make a workload reliable: health probes and resources
- Provide persistent storage to an application
- Run an agent on every node (DaemonSet)
- Run one-off and scheduled tasks (Job, CronJob)
- Scale an application automatically
Observe and troubleshoot a cluster 5
Understand, install and maintain a cluster 10
- Back up and restore a cluster's state
- Cap a namespace's resources
- Control where Pods are placed
- Detect and migrate deprecated APIs before an upgrade
- Explain the architecture of a Kubernetes cluster
- Install a Kubernetes cluster
- Maintain and manage nodes without service interruption
- Make the control plane of a kubeadm cluster highly available
- Upgrade a kubeadm cluster by one minor version
- Use custom resources and operators
Secure a Kubernetes cluster 9
- Authorize access to the Kubernetes API with RBAC
- Confine a container against the host kernel (seccomp, AppArmor)
- Encrypt and authenticate traffic between Pods
- Give a workload a minimal identity (ServiceAccount)
- Harden a cluster's components with the CIS Benchmark
- Harden a Pod's execution context (securityContext)
- Isolate a Pod in a sandboxed runtime (RuntimeClass)
- Make the cluster reject what breaks a security rule
- Trace who acted on the API with the Kubernetes audit log
Deploy applications with Helm 2
Design and distribute Helm charts 3
Make an application cloud native on Kubernetes 5
- Assess a CNCF project before adopting it: maturity, governance and project health
- Audit an application factor by factor (12-factor) on Kubernetes and fix its gaps
- Enforce timeouts, retries and identity-based authorization between services with a mesh
- Match a cluster's node count to pending Pods and shrink it without disrupting the service
- Serve an application with scale-to-zero on Knative and measure its cold start
CI/CD
15
Understand and build a delivery chain, whatever the tool 4
Build and run CI 5
Secure the delivery chain 5
Make a GitLab CI pipeline reliable 1
GitOps
3
Provisioning
28
Provision as code with Terraform 12
- Consume and version Terraform modules reproducibly
- Control the ordering, replacement and guardrails of Terraform resources
- Declare Terraform resources and data sources with pinned providers
- Design, structure and test a reusable Terraform module
- Generate Terraform resources in a controlled way with expressions, functions, count and for_each
- Handle sensitive data in Terraform without exposing it in outputs or state
- Initialise, run and troubleshoot a Terraform project, from init to destroy
- Inspect and repair a Terraform state, move or remove resources without recreating them
- Organize several environments and a Terraform repository without dangerous coupling
- Parameterize a Terraform project and expose its results without duplicating values
- Run Terraform non-interactively in a pipeline, with guardrails
- Share a remote, locked and recoverable Terraform state
Build machine images with Packer 3
Provision and govern in the cloud with Terraform 3
Reason about and maintain infrastructure as code, whatever the tool 7
- Choose an IaC approach and record the decision: provision or configure, change or replace, push or pull
- Choose the IaC tool family that fits the problem: resources, configuration, images, language
- Deliver infrastructure as code under control: approved plan, policies, engine identity and cost
- Evolve an existing infrastructure in code: import, drift, replacement and destruction
- Keep an IaC repository healthy: layered structure, plan review, testing pyramid and secrets out of the code
- Predict what an IaC tool will create, change or destroy: declarative model, idempotence, state and plan
- Structure infrastructure as code at scale: stacks, versioned modules, environments and debt
Provision and industrialise with Pulumi 2
Test cloud code on an emulator 1
Configuration management
48
Configure a fleet with Ansible 9
- Control playbook execution: parallelism, async, delegation and inclusion
- Describe a fleet in a static Ansible inventory: groups, variables and patterns
- Install Ansible and configure its control node
- Parameterise an Ansible playbook: variables, facts, precedence and Jinja2 filters
- Prepare managed nodes and run ad hoc commands
- Protect the secrets of an Ansible project: Ansible Vault and external vaults
- Structure Ansible into roles and collections
- Troubleshoot and run Ansible in production: verbosity, debugger, idempotence and ansible-pull
- Write a readable, idempotent Ansible playbook
Write robust playbooks 5
- Check preconditions and synchronize a playbook's execution
- Generate a configuration file through Ansible from a Jinja2 template
- Handle a failed Ansible task: recover, ignore or stop the play
- Make Ansible tasks conditional and repeat them with when and loop
- Run a raw command through Ansible idempotently and report it correctly
Administer a system with Ansible 9
- Connect Ansible to a Windows fleet
- Copy, fetch and archive files with Ansible idempotently
- Download a verified artifact and talk to an HTTP API from a playbook
- Drive a host's services, scheduled tasks, hostname and reboots with Ansible
- Edit an existing configuration file with Ansible without rewriting it
- Harden a host with Ansible: firewall, SELinux and kernel parameters
- Install packages and declare repositories with Ansible across distributions
- Manage accounts, groups, SSH keys and sudo rights with Ansible
- Partition, format and mount storage with Ansible, LVM included
Industrialize Ansible roles 4
Tool and extend Ansible 4
Configure a fleet with Chef 8
- Lock cookbooks with Policyfiles and deliver them without a server
- Make a cookbook configurable and portable: attributes, templates, Ohai
- Measure and fix a server's compliance with InSpec and Chef
- Protect a Chef fleet's secrets: encrypted data bags and chef-vault
- Run a fleet with a CINC server: enrollment, search, policy groups, pull mode
- Structure a maintainable cookbook: recipes, custom resources, notifications, lint
- Test a cookbook before and after convergence: ChefSpec, InSpec, Test Kitchen, CI
- Write a Chef cookbook and converge it idempotently, in a container then on a VM
Drive a fleet's compliance with Rudder 2
Configure a fleet with Salt 5
- Coordinate a Salt fleet: multi-node orchestration, Salt SSH and Reactor
- Describe a server's desired state in idempotent Salt states
- Drive a fleet remotely with Salt: master, minions, keys and targeting
- Industrialize Salt: GPG secrets, states from Git, a hardened master, automatic enrollment
- Make states generic with grains, pillars, Jinja and managed files
Build an Ansible fleet's inventory 2
Security
24
Write, verify and deliver Rego policies 4
Secure the delivery chain 2
Hold a system's secrets, from inventory to leak 6
- Detect an exposed secret, measure the reach of the leak and deal with it
- Issue a secret with a bounded lifetime, renew it and revoke it in an emergency
- List a system's secrets, rank them by criticality and keep their register
- Run a vault in production: initialise, seal, back up and monitor it
- Scope access to a vault to the strict minimum and explain a denial
- Store a secret in a vault and read it without ever writing it in clear
Think about security at every step 6
Go deeper into end-to-end security 3
Understand threats and reason about defense 3
DevSecOps
4
Identity and access
8
Centralize identity and access 8
- Connect an application to an identity provider with OpenID Connect, validate its tokens and troubleshoot an OIDC or SAML integration
- Connect the Kubernetes API server and Vault to an OIDC identity provider, turn token groups into limited rights and diagnose a denial
- Federate an LDAP or Active Directory directory and a partner identity provider into Keycloak
- Manage the account lifecycle in Keycloak with SCIM and Workflows, handle a departure and run an access review
- Protect an API with OAuth 2 tokens: audience, scopes, machine access and choosing the flow of a client without a browser
- Require a second factor per group in Keycloak, with forced enrolment and recovery, and set a password policy compliant with NIST SP 800-63B-4
- Run Keycloak in production: TLS proxy, restored backup, version upgrade, emergency access and a realm described in Terraform
- Set up Keycloak on PostgreSQL and administer a realm: users, groups, roles and event logs
Virtualization
20
Understand virtualization and choose a type of hypervisor 1
Set up a hypervisor and its instances (KVM, Proxmox VE or Incus) 4
- Connect instances to the network and expose their services: NAT, bridge, VLAN and troubleshooting
- Create ready-to-use instances: storage, creation, configured first boot and guest agent
- Describe and deploy instances in Terraform with the hypervisor's provider
- Set up a hypervisor and check that it works
Virtualize with KVM and libvirt 4
Operate an Incus host 5
- Automate Incus with Ansible: connection plugin, provisioning and custom images
- Migrate to Incus: VMware VMs, an LXD installation, a physical or virtual machine
- Operate Incus instances: OCI images, storage, profiles, projects and GPUs
- Secure an Incus server and its remote administration
- Troubleshoot an Incus VM stuck at boot
Operate a Proxmox VE platform 3
Build a private cloud with Incus 3
- Administer Incus OS nodes through the API: seed installation, A/B updates, Tailscale, backup, monitoring and fleet
- Build and run an Incus cluster: joining, quorum and roles, workers, shared CephFS storage
- Isolate tenants on Incus: OVN VPCs, load balancer, ACLs, quotas, scoped credentials and a 3-tier deployment in Terraform
Cloud
45
Build a cloud infrastructure, Scaleway or Outscale 4
Industrialize the cloud as code: Terraform, Packer, Ansible 3
Run a managed Kubernetes in the cloud 1
Govern and secure a Scaleway account 3
Operate Scaleway managed services 4
- Deliver an application on Kapsule: private registry, Ingress or Load Balancer, persistent volumes
- Expose a Scaleway service: Public Gateway, bastion and Load Balancer
- Observe your Scaleway resources with Cockpit and find a past incident
- Operate a managed Scaleway PostgreSQL database on a private network, back it up and restore it
Make Outscale reliable, audit and extend it: high availability, Well-Architected, Talos 5
- Assess an Outscale architecture pillar by pillar with the Well-Architected grid
- Choose your Outscale region, API and qualification level
- Integrate a self-managed Talos Kubernetes cluster with Outscale: OMI, CCM, CSI and fGPU
- Make a service highly available across Outscale subregions: LBU and DNS, or HAProxy and a floating EIP
- Structure Outscale identities, permissions and accounts with EIM
Design a cloud environment without depending on the provider 7
- Choose a data service, managed or self-managed, and connect it privately, replication and failover included
- Choose a workload's compute model and size it from measurements
- Choose a workload's service and deployment model and split responsibilities
- Choose a workload's storage family and class from access, measured performance, durability and cost
- Choose the interconnection and network pattern of a hybrid environment: VPN, dedicated link, BGP, DMZ and hub-spoke
- Design a cloud environment's private network: addressing, a regional network attached in several zones, routing and default-deny filtering
- Estimate a cloud architecture's monthly cost from dated price lists
Grant minimal cloud access, to humans and workloads alike 2
Expose a cloud workload and make it withstand failures 3
Rebuild and run a cloud environment 2
Govern cloud usage: guardrails, costs and sovereignty 4
- Assess a cloud provider on jurisdiction, dependencies, key custody and reversibility, and cost its exit
- Cut a cloud architecture's bill without degrading the required resilience
- Design a multi-team cloud environment's organisation: account boundaries, hierarchy and landing zone
- Organize a multi-team cloud environment: separate accounts, guardrails as code and tagging
Plan the migration of an application estate to the cloud 1
Defend a cloud architecture in review 1
Decide on a target cloud architecture 1
Recommend the evolution of a cloud architecture 1
Design a cloud environment's identity and access model 1
Test cloud code on an emulator 2
Development
8
Go deeper into a language: concurrency, performance, metaprogramming 4
Get started with the developer's craft in Python: read, test, review, ship 4
Data formats
17
Write, check and query configuration and data formats 11
- Consume a REST API reliably from a shell script
- Format, validate and lint HCL files, in CI and locally
- Produce correctly typed and escaped JSON from a script
- Query and modify a YAML document reproducibly
- Query and modify HCL files from a script, verifiably
- Query structured output with JMESPath (AWS CLI, Azure CLI, Ansible)
- Query structured output with JSONPath, notably in kubectl
- Read and write correct HCL, separating the language from what Terraform and Packer add
- Validate a YAML document with linting, schemas and automated checks
- Validate JSON strictly and against a JSON Schema
- Write and review a correct, unambiguous YAML document
Query, modify and evolve a relational database with SQL 5
Process text and files on the command line 1
Applied AI
25
Work with a coding agent 3
Frame and secure a coding agent 2
Extend and industrialize a coding agent 4
Understand, serve and integrate language models 5
- Call an LLM from Python: completion, streaming, conversation, structured output and images
- Explain how an LLM works, its inference and its quantization
- Operate an LLM gateway: routing, fallback, cache, keys and budgets
- Run and serve an open source LLM, from the workstation to the GPU
- Write reliable prompts: roles, few-shot, Chain-of-Thought and ReAct
Build a RAG 3
Build and industrialize MCP servers 2
Build AI agents 3
Assemble, observe and secure a sovereign AI stack 3
Documentation
10
Document a service or a project 10
- Build a technical presentation in Markdown or HTML, versioned and exported
- Build and publish documentation checked in CI
- Choose the document type and its reader before writing
- Document code: comments that say why, docstrings, generated reference
- Give a repository its README, CHANGELOG and ADRs
- Keep documentation alive: owner, review, freshness
- Model an architecture beyond context: components, dynamic and deployment views, a single model in code
- Represent a system with diagrams as code that read without the image
- Write a clear, accessible and verifiable technical page
- Write a technical document in AsciiDoc: structure, attributes, blocks and conversion
Machine learning
10
Frame, equip, train and reproduce machine learning models 10
- Frame a machine learning problem: choose the learning family and place the work in the project lifecycle
- Group unlabelled data with k-means and choose the number of clusters (elbow, silhouette)
- Make a training run reproducible and describe it as a parameterised pipeline replayed identically (uv, DVC)
- Register and version a model and refer to it by alias with its lineage (MLflow)
- Set up a reproducible data science workstation: a pinned conda environment and a Jupyter notebook that runs end to end
- Test data and model before promotion: schema, ranges, threshold and non-regression against the champion (pytest)
- Track every training run on a tracking server and find the run that produced a model (MLflow)
- Train a linear regression and evaluate it on a test set (scikit-learn, R², RMSE)
- Train a small neural network on CPU with PyTorch and read its decision boundary
- Version a dataset outside Git and get back an exact version of it (DVC)
forge
6
Administer a self-hosted Git forge 6
- Back up Forgejo, copy the encrypted backup off the machine, restore it on a blank stack and write the recovery runbook
- Govern access to Forgejo: organisations, teams and permissions, sign-in through an OIDC provider with an enforced second factor, and account support from the command line
- Maintain Forgejo and upgrade it: scheduled tasks, doctor and quotas, an upgrade rehearsed on a copy with validation criteria and rollback from the backup
- Monitor Forgejo through its logs and Prometheus metrics, fire an alert and diagnose a database outage
- Secure a Forgejo instance: webhooks kept off the internal network, brute force banned with fail2ban, a break-glass administrator account, scoped tokens and signed commits
- Set up Forgejo on PostgreSQL behind a TLS proxy, reachable over HTTPS and SSH, then configure mail, LFS and sign-ups
No skill matches these criteria.