Qu'est-ce qu'un security engineer ? Fiche métier

Un security engineer est un ingénieur logiciel spécialisé dans la construction d'outils, de plateformes et d'automations de sécurité pour une organisation. Il combine compétences développement (Python, Go, Rust fréquents) et expertise cybersécurité (cryptographie appliquée, threat modeling, detection). Le rôle se distingue du DevSecOps (qui configure des pipelines avec outils sur étagère), de l'AppSec engineer (qui audite un produit spécifique) et du SRE (Site Reliability Engineer, focus fiabilité). Le security engineer construit — SDK internes, frameworks de détection, plateformes de secrets management, pipelines d'anomaly detection. Taux de coding quotidien 60-80 %, le plus élevé des métiers cyber. Quatre spécialisations : Platform Security Engineer, Detection Engineer, Product Security Engineer, Infrastructure Security Engineer. Salaires juniors 55-75 k€ bruts IDF, senior 100-140 k€, staff 130-180 k€, principal 160-220 k€. Alignement salarial avec les staff engineers software plus prime de rareté cyber. Cet article détaille la définition, la distinction avec métiers voisins, les quatre spécialisations, le socle technique, les projets types et le profil qui réussit.

1. Définition précise : qu'est-ce qu'un security engineer ?

Le terme « security engineer » vient du vocabulaire anglo-saxon (Google, Microsoft, Meta, Netflix ont popularisé le rôle) et s'est installé en France dans les scale-ups tech, fintech et grandes entreprises à ingénierie forte (banques avec équipes tech matures, GAFAM France). Trois caractéristiques structurent le métier.

Posture de builder, pas d'opérateur ni d'auditeur

Le security engineer construit des artefacts réutilisables : un SDK d'authentification utilisé par 50 microservices, une plateforme de vulnerability management partagée par toute l'ingénierie, un framework de detection engineering appliqué à l'ensemble des produits. Son livrable est du code qui tourne en production et qui sert d'autres équipes, pas un rapport ou une configuration ponctuelle.

Socle software engineering fort

Contrairement aux autres métiers cyber qui peuvent s'exercer sans expérience dev significative (analyste GRC, SOC L1, auditeur), le security engineer exige un socle ingénieur logiciel solide : 3+ ans d'expérience backend minimum, maîtrise d'au moins un langage compilé moderne (Go ou Rust recommandés en 2026), pratique des tests automatisés, compréhension de l'architecture microservices.

Double compétence sur la durée

Un security engineer senior maintient sa double compétence dans le temps : il code quotidiennement et lit les nouveaux papers de recherche cyber (Black Hat, DEF CON, SSTIC). Les profils qui perdent l'une des deux dimensions (pur dev sans veille cyber, ou pur cyber sans code récent) sortent progressivement du métier vers d'autres rôles.

2. Security engineer vs DevSecOps vs AppSec engineer : distinctions

Trois métiers techniques proches, souvent confondus en entretien. Tableau comparatif opérationnel.

Recouvrement en PME : en PME de 30-150 personnes, une seule personne couvre souvent tous ces rôles. La distinction fonctionnelle apparaît clairement à partir de 300-500 personnes avec équipes cyber dédiées.

Pour les métiers voisins en détail, voir Qu'est-ce qu'un DevSecOps ? Fiche métier et Qu'est-ce qu'un AppSec engineer ? Fiche métier.

3. Les quatre types de security engineers

Quatre spécialisations dominantes en France 2026.

Platform Security Engineer

Construction de la plateforme sécurité interne partagée par toute l'ingénierie : authentification interservices (mTLS, JWT), autorisation centralisée (OPA, SpiceDB), secrets management (Vault wrapper custom), PKI interne, logging sécurisé, frameworks de rate limiting. Emploi typique dans les scale-ups cloud-natives et licornes fintech.

Livrables types : SDK d'authentification pour services Go ou Python, service de secrets management custom avec rotation automatique, plateforme de distribution de certificats TLS internes.

Detection Engineer

Écriture et maintenance de règles de détection à l'échelle : Sigma rules custom, requêtes SIEM (SPL Splunk, KQL Sentinel, Elastic DSL), règles YARA pour malware detection, pipelines d'anomaly detection avec machine learning. Rôle spécialisé dans les grandes équipes SOC matures (banques, OIV, licornes sécurité).

Livrables types : dépôt GitHub de 200+ règles Sigma personnalisées, plateforme de test de détection automatisée (Atomic Red Team intégré), dashboards de coverage MITRE ATT&CK.

Product Security Engineer

Security engineering embarquée dans un produit SaaS B2B : sécurisation de l'authentification utilisateurs finals, audit log immuable pour conformité, features sécurité vendues aux clients (SSO SAML, SCIM, audit log export). Rôle à cheval entre AppSec et product engineering.

Livrables types : feature SSO SAML 2.0 avec support Okta / Azure AD, audit log immuable stocké via append-only ledger, SCIM 2.0 provisioning automatique pour comptes clients.

Infrastructure Security Engineer

Sécurisation de l'infrastructure partagée : durcissement Kubernetes clusters, politiques OPA/Kyverno à l'échelle, monitoring runtime (Falco, Tetragon), automation cloud security. Souvent couplé DevSecOps dans les équipes restreintes.

Livrables types : cluster Kubernetes durci avec CIS Benchmarks 100 %, politique Gatekeeper transverse appliquée sur 15 clusters, automation de réponse à incidents cloud.

4. Stack technique et socle dev attendu

Langages

• Python : incontournable. Utilisé pour tooling interne, automation, detection scripting, intégrations API. Écosystème cyber massif (Impacket, Mitmproxy, Cryptography).
• Go : très valorisé en 2026, dominant dans l'écosystème cloud-native (Kubernetes, Terraform, nombreux outils cyber). Typé, performant, déploiement mono-binaire.
• Rust : en forte montée. Choisi pour outils cyber critiques (cryptographie, parsers sécurisés). À maîtriser pour les postes senior+ dans 3-5 ans.
• Java ou Kotlin : selon contexte grand groupe bancaire ou Android.
• TypeScript : pour les outils internes avec interface web.

Architecture et infrastructure

• Microservices et event-driven : Kafka, RabbitMQ, NATS, patterns CQRS.
• Cloud natif : AWS, Azure ou GCP en profondeur (au moins un, idéalement deux).
• Kubernetes : design déclaratif, admission policies, CRDs, operators pattern.
• Terraform : pour IaC sécurisée par défaut, modules réutilisables.
• Observability : OpenTelemetry, Prometheus, Grafana, ELK, Datadog.

Compétences sécurité spécifiques

• Cryptographie appliquée : AES-GCM, RSA, ECC (secp256k1, Ed25519), HSM, KMS, constant-time programming.
• Auth et Authz : OAuth 2.0 avec PKCE, OIDC, JWT (anti-patterns), SAML 2.0, RBAC et ABAC, SCIM.
• Threat modeling : STRIDE, PASTA, appliqué aux plateformes internes.
• OWASP et MITRE ATT&CK : compréhension transverse.

Exemple concret : SDK JWT d'authentification interne

Livrable type d'un Platform Security Engineer — bibliothèque Python réutilisable par tous les services internes :

"""
SDK interne d'authentification JWT avec cache JWKS.
Livrable type d'un Platform Security Engineer : bibliotheque
reutilisable par 50+ services internes de l'organisation.
"""
import time
from dataclasses import dataclass
from typing import Optional
import jwt  # PyJWT
import requests
 
 
@dataclass
class TokenValidationResult:
    valid: bool
    subject: Optional[str] = None
    claims: Optional[dict] = None
    error: Optional[str] = None
 
 
class InternalAuthClient:
    """Client reutilisable pour validation JWT dans les services internes."""
 
    def __init__(
        self,
        jwks_url: str,
        expected_issuer: str,
        expected_audience: str,
        cache_ttl_seconds: int = 3600,
    ):
        self.jwks_url = jwks_url
        self.expected_issuer = expected_issuer
        self.expected_audience = expected_audience
        self.cache_ttl = cache_ttl_seconds
        self._jwks_cache: dict = {}
        self._cache_expiry: float = 0
 
    def _get_signing_key(self, kid: str):
        """Recupere la cle publique depuis le JWKS endpoint avec cache."""
        if time.time() > self._cache_expiry:
            resp = requests.get(self.jwks_url, timeout=5)
            resp.raise_for_status()
            jwks = resp.json()
            self._jwks_cache = {k["kid"]: k for k in jwks["keys"]}
            self._cache_expiry = time.time() + self.cache_ttl
        return self._jwks_cache.get(kid)
 
    def validate_token(self, token: str) -> TokenValidationResult:
        """Valide un JWT et retourne les claims si OK, erreur sinon."""
        try:
            header = jwt.get_unverified_header(token)
            kid = header.get("kid")
            if not kid:
                return TokenValidationResult(valid=False, error="Token sans kid")
            key = self._get_signing_key(kid)
            if not key:
                return TokenValidationResult(
                    valid=False,
                    error=f"kid {kid} introuvable dans JWKS",
                )
            claims = jwt.decode(
                token,
                key,
                algorithms=["RS256"],
                audience=self.expected_audience,
                issuer=self.expected_issuer,
            )
            return TokenValidationResult(
                valid=True,
                subject=claims.get("sub"),
                claims=claims,
            )
        except jwt.ExpiredSignatureError:
            return TokenValidationResult(valid=False, error="Token expire")
        except jwt.InvalidTokenError as exc:
            return TokenValidationResult(valid=False, error=str(exc))

Ce type de SDK, publié dans un dépôt interne (privé GitHub Enterprise, GitLab interne, Artifactory), est ensuite intégré dans tous les services Python de l'organisation comme dépendance. La qualité, la couverture de tests et la documentation déterminent son adoption.

5. Exemples de projets et livrables types

Projets représentatifs d'un security engineer confirmé sur une année dans une scale-up tech.

Chaque projet produit du code versionné, des tests automatisés, une documentation et une intégration avec les outils existants de l'organisation. Le livrable est utilisable par d'autres équipes après livraison — pas juste publié puis abandonné.

6. Salaires, trajectoires et bifurcations

Trajectoire salariale

Fourchettes Apec Cadres 2023-2024, Numeum, levels.fyi France. Les licornes fintech (Qonto, Swile, Alan, Shift Technology, Dataiku) et GAFAM France tirent les fourchettes hautes (+20-30 % sur les niveaux senior et staff), alignées sur les staff engineers software de ces organisations.

Employeurs types

• GAFAM France : Google Paris, Meta Paris, Amazon Paris, Microsoft France, Apple Paris. Équipes security engineer dédiées de 20-200 personnes.
• Licornes fintech et SaaS B2B : Qonto, Swile, Alan, Dataiku, Algolia, Doctolib, Mistral AI, Shift Technology. Équipes 5-30 security engineers en forte croissance.
• Banques avec ingénierie tech mature : Société Générale Digital Factory, BNP Paribas Cyber Tech, Crédit Agricole Digital.
• Éditeurs SaaS cyber : GitGuardian, Snyk Paris, Sekoia.io, Dashlane (product security).
• Secteur public tech : DINUM, DGA Tech Innovations, ANSSI labs.

Bifurcations classiques après 5-7 ans

• Staff Security Engineer : figure technique senior, principal contributeur technique, mentor des juniors.
• Lead Security Engineer : management léger d'une équipe 3-8 personnes, cumul avec contributeur actif.
• Architecte sécurité : vision transverse plus haute, moins de code au quotidien.
• Principal Engineer : niveau pair avec CTO junior, influence stratégique forte.
• CTO dans une startup cyber : bascule entrepreneuriale.
• Consultant indépendant senior : TJM 1 000-1 500 €, missions de construction d'outils internes.

Pour la trajectoire senior vers management cyber générique, voir Les étapes pour devenir RSSI.

7. Pour qui le métier de security engineer convient-il ?

Traits qui fonctionnent en security engineer

• Passion durable du code : plaisir à écrire, tester, refactorer. Coding en dehors du travail (projets perso, open source) fréquent.
• Socle software engineering solide : 3+ ans d'expérience dev backend minimum avant la bascule cyber.
• Curiosité profonde en cyber : lecture de papers académiques, CVE récentes, veille Black Hat / DEF CON / SSTIC.
• Tolérance aux cycles longs : un SDK interne se construit sur 3-6 mois avant utilisation réelle. Acceptation des projets non immédiatement visibles.
• Appétit pour les systèmes distribués : microservices, event-driven, state management à l'échelle.

Traits qui signalent un mauvais match

• Pas de background dev backend solide → 18-24 mois de consolidation avant viabilité.
• Préférence pour les livrables visibles rapidement → plutôt pentest, audit ou DevSecOps.
• Rejet de la complexité architecturale → plutôt SOC analyst ou GRC.
• Mauvaise tolérance au code legacy → la maintenance d'outils internes fait partie du job.

Trajectoires d'entrée

• Via développeur backend 4+ ans : la trajectoire la plus commune et la plus fluide. Apprentissage cyber en parallèle + bascule interne ou externe vers équipe cyber.
• Via AppSec engineer confirmé : bascule naturelle vers security engineer si le socle code est solide.
• Via DevSecOps senior : bascule si appétit pour le build vs la configuration. 2-4 ans supplémentaires d'investissement code.
• Via reconversion complète : rare, nécessite 3-5 ans de dev backend avant la dimension cyber.

Points clés à retenir

• Security engineer = software engineer avec spécialisation cyber. 60-80 % du temps en code. Le plus coding-heavy des métiers cyber.
• Distinction : security engineer construit (SDK, plateformes), DevSecOps configure (pipelines), AppSec audite (threat model, code review).
• 4 spécialisations : Platform Security, Detection Engineer, Product Security, Infrastructure Security.
• Stack : Python + Go + Rust en montée, microservices, cloud natif (AWS/Azure/GCP), Kubernetes, Terraform, cryptographie appliquée, OAuth 2.0 + JWT.
• Salaires : junior 55-75 k€ IDF, senior 100-140 k€, staff 130-180 k€, principal 160-220 k€. Licornes et GAFAM tirent fourchettes hautes (+20-30 %).
• Bascule idéale : dev backend 4+ ans + apprentissage cyber 12-18 mois. L'inverse (cyber généraliste apprenant à coder tard) produit plutôt DevSecOps.

Pour l'ensemble des métiers cyber avec salaires et accessibilité par profil, voir Les métiers de la cybersécurité : guide complet. Pour comparer avec les métiers voisins coding-oriented, voir Qu'est-ce qu'un DevSecOps ? Fiche métier, Qu'est-ce qu'un AppSec engineer ? Fiche métier et Qu'est-ce qu'un ingénieur cloud security ? Fiche métier. Pour comprendre la trajectoire blue team qui peut alimenter le parcours detection engineer, voir Qu'est-ce qu'un blue teamer ? Fiche métier complète. L'accompagnement cyber 6 mois ne cible pas directement le security engineer (métier qui exige un socle dev senior préalable), mais peut servir de complément cyber pour les développeurs backend confirmés qui visent cette bascule en 12-18 mois.