diff --git a/helm/tls-sync-wildcard/ops/VÉRIFICATION.md b/helm/tls-sync-wildcard/ops/VÉRIFICATION.md
new file mode 100644
index 0000000..d65935d
--- /dev/null
+++ b/helm/tls-sync-wildcard/ops/VÉRIFICATION.md
@@ -0,0 +1,268 @@
+# Guide de Vérification - TLS Sync Wildcard
+
+Ce guide vous explique comment vérifier que le CronJob de synchronisation des certificats wildcard fonctionne correctement.
+
+## 1. Vérifier que le CronJob est déployé
+
+```bash
+# Vérifier que le CronJob existe
+kubectl get cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops
+
+# Voir les détails du CronJob
+kubectl describe cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops
+
+# Vérifier le schedule configuré
+kubectl get cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops -o jsonpath='{.spec.schedule}' && echo
+```
+
+**Résultat attendu** : Le CronJob doit être présent avec un schedule (par exemple `0 * * * *` pour toutes les heures).
+
+## 2. Vérifier que les Jobs sont créés
+
+```bash
+# Lister tous les Jobs créés par le CronJob
+kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops
+
+# Voir les Jobs récents (dernières 24h)
+kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --sort-by=.metadata.creationTimestamp | tail -5
+
+# Vérifier le statut du dernier Job
+kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops -o wide | head -2
+```
+
+**Résultat attendu** : Vous devriez voir des Jobs avec le statut `Complete` ou `Running`.
+
+## 3. Voir les logs des Jobs
+
+```bash
+# Voir les logs du dernier Job
+kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=100
+
+# Voir les logs d'un Job spécifique
+JOB_NAME=$(kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --sort-by=.metadata.creationTimestamp -o jsonpath='{.items[-1].metadata.name}')
+kubectl logs -n certificates-ops job/$JOB_NAME --context=cluster-ops
+
+# Suivre les logs en temps réel (si un Job est en cours)
+kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops -f
+```
+
+**Résultat attendu** : Les logs doivent montrer :
+- `=== Synchronisation automatique des secrets TLS ===`
+- `📋 Traitement du certificat: wildcard-dev-tls`
+- `🌐 Certificat wildcard détecté`
+- `✅ Synchronisé avec succès dans <namespace>`
+
+## 4. Vérifier que les secrets sont synchronisés
+
+### Dans le cluster DEV
+
+```bash
+# Vérifier que le secret existe dans headlamp-dev
+kubectl get secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev
+
+# Vérifier que le secret existe dans homarr-dev
+kubectl get secret wildcard-dev-tls -n homarr-dev --context=cluster-dev
+
+# Vérifier que le secret existe dans longhorn-dev
+kubectl get secret wildcard-dev-tls -n longhorn-dev --context=cluster-dev
+
+# Vérifier les détails d'un secret (date de création, taille, etc.)
+kubectl describe secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev
+```
+
+**Résultat attendu** : Les secrets doivent exister dans tous les namespaces configurés.
+
+### Comparer les secrets entre namespaces
+
+```bash
+# Comparer les certificats (doivent être identiques)
+kubectl get secret wildcard-dev-tls -n certificates-ops --context=cluster-ops -o jsonpath='{.data.tls\.crt}' | base64 -d | openssl x509 -noout -subject -dates
+kubectl get secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev -o jsonpath='{.data.tls\.crt}' | base64 -d | openssl x509 -noout -subject -dates
+```
+
+**Résultat attendu** : Les certificats doivent être identiques (même sujet, mêmes dates).
+
+## 5. Déclencher manuellement une synchronisation
+
+```bash
+# Créer un Job manuel à partir du CronJob
+kubectl create job --from=cronjob/tls-sync-wildcard tls-sync-wildcard-manual-$(date +%s) -n certificates-ops --context=cluster-ops
+
+# Attendre quelques secondes puis voir les logs
+sleep 5
+kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=50
+```
+
+**Résultat attendu** : Un nouveau Job est créé et exécuté immédiatement.
+
+## 6. Vérifier les permissions RBAC
+
+```bash
+# Vérifier que le ServiceAccount existe
+kubectl get serviceaccount tls-sync-wildcard -n certificates-ops --context=cluster-ops
+
+# Vérifier que le ClusterRole existe
+kubectl get clusterrole tls-sync-wildcard --context=cluster-ops
+
+# Vérifier que le ClusterRoleBinding existe
+kubectl get clusterrolebinding tls-sync-wildcard --context=cluster-ops
+
+# Tester les permissions du ServiceAccount
+kubectl auth can-i get secrets --namespace=certificates-ops --as=system:serviceaccount:certificates-ops:tls-sync-wildcard --context=cluster-ops
+kubectl auth can-i create secrets --namespace=headlamp-dev --as=system:serviceaccount:certificates-ops:tls-sync-wildcard --context=cluster-dev
+```
+
+**Résultat attendu** : Toutes les commandes doivent retourner `yes`.
+
+## 7. Vérifier le ConfigMap avec le script
+
+```bash
+# Vérifier que le ConfigMap existe
+kubectl get configmap tls-sync-wildcard-script -n certificates-ops --context=cluster-ops
+
+# Voir le contenu du script (premières lignes)
+kubectl get configmap tls-sync-wildcard-script -n certificates-ops --context=cluster-ops -o jsonpath='{.data.sync-all-certificates\.sh}' | head -20
+```
+
+**Résultat attendu** : Le ConfigMap doit exister et contenir le script.
+
+## 8. Vérifier le Secret kubeconfig
+
+```bash
+# Vérifier que le Secret existe
+kubectl get secret tls-sync-kubeconfig -n certificates-ops --context=cluster-ops
+
+# Vérifier que le fichier config est présent
+kubectl get secret tls-sync-kubeconfig -n certificates-ops --context=cluster-ops -o jsonpath='{.data.config}' | base64 -d | head -5
+```
+
+**Résultat attendu** : Le Secret doit exister et contenir un fichier `config` valide.
+
+## 9. Script de vérification complète
+
+Créez un script pour vérifier tout d'un coup :
+
+```bash
+#!/bin/bash
+# Script de vérification complète du TLS Sync
+
+echo "=== Vérification du TLS Sync Wildcard ==="
+echo ""
+
+echo "1. CronJob..."
+kubectl get cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops 2>/dev/null && echo "✅ CronJob existe" || echo "❌ CronJob manquant"
+
+echo ""
+echo "2. Derniers Jobs..."
+kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --sort-by=.metadata.creationTimestamp | tail -3
+
+echo ""
+echo "3. Secrets dans cluster-dev..."
+for ns in headlamp-dev homarr-dev longhorn-dev; do
+  if kubectl get secret wildcard-dev-tls -n "$ns" --context=cluster-dev &>/dev/null; then
+    echo "✅ $ns: secret présent"
+  else
+    echo "❌ $ns: secret manquant"
+  fi
+done
+
+echo ""
+echo "4. Logs du dernier Job..."
+kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=20 2>/dev/null | tail -5
+
+echo ""
+echo "=== Vérification terminée ==="
+```
+
+## 10. Dépannage des problèmes courants
+
+### Le CronJob ne crée pas de Jobs
+
+```bash
+# Vérifier les événements
+kubectl get events -n certificates-ops --context=cluster-ops --sort-by='.lastTimestamp' | grep tls-sync-wildcard | tail -10
+
+# Vérifier le schedule
+kubectl get cronjob -n certificates-ops tls-sync-wildcard --context=cluster-ops -o yaml | grep -A 2 schedule
+```
+
+### Les Jobs échouent
+
+```bash
+# Voir les détails du Job en échec
+kubectl describe job -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops | tail -30
+
+# Voir les logs d'erreur
+kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=100 | grep -i error
+```
+
+### Les secrets ne sont pas synchronisés
+
+```bash
+# Vérifier que le certificat source existe
+kubectl get certificate wildcard-dev-tls -n certificates-ops --context=cluster-ops
+
+# Vérifier que le secret source existe
+kubectl get secret wildcard-dev-tls -n certificates-ops --context=cluster-ops
+
+# Vérifier les logs pour voir pourquoi la synchronisation a échoué
+kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=200 | grep -A 10 "wildcard-dev-tls"
+```
+
+### Erreur "context not found"
+
+```bash
+# Vérifier que le Secret kubeconfig contient tous les contextes
+kubectl get secret tls-sync-kubeconfig -n certificates-ops --context=cluster-ops -o jsonpath='{.data.config}' | base64 -d | grep -E "contexts:|name:"
+
+# Tester l'accès aux clusters depuis un pod de test
+kubectl run -it --rm test-kubeconfig --image=bitnami/kubectl:1.31 --restart=Never \
+  -n certificates-ops \
+  --context=cluster-ops \
+  --overrides='
+{
+  "spec": {
+    "containers": [{
+      "name": "test-kubeconfig",
+      "image": "bitnami/kubectl:1.31",
+      "volumeMounts": [{
+        "name": "kubeconfig",
+        "mountPath": "/root/.kube",
+        "readOnly": true
+      }]
+    }],
+    "volumes": [{
+      "name": "kubeconfig",
+      "secret": {
+        "secretName": "tls-sync-kubeconfig"
+      }
+    }]
+  }
+}' \
+  -- kubectl config get-contexts
+```
+
+## 11. Monitoring continu
+
+Pour surveiller en continu :
+
+```bash
+# Watch les Jobs
+watch -n 5 'kubectl get jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops'
+
+# Watch les secrets dans un namespace
+watch -n 10 'kubectl get secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev'
+```
+
+## Résumé des commandes essentielles
+
+```bash
+# Vérification rapide (tout en une fois)
+kubectl get cronjob,jobs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops && \
+kubectl logs -n certificates-ops -l app=tls-sync-wildcard --context=cluster-ops --tail=30 && \
+echo "--- Secrets dans cluster-dev ---" && \
+kubectl get secret wildcard-dev-tls -n headlamp-dev --context=cluster-dev && \
+kubectl get secret wildcard-dev-tls -n homarr-dev --context=cluster-dev && \
+kubectl get secret wildcard-dev-tls -n longhorn-dev --context=cluster-dev
+```
+
diff --git a/helm/tls-sync-wildcard/ops/values.yaml b/helm/tls-sync-wildcard/ops/values.yaml
index e845606..bb1eaa7 100644
--- a/helm/tls-sync-wildcard/ops/values.yaml
+++ b/helm/tls-sync-wildcard/ops/values.yaml
@@ -1,7 +1,7 @@
 # Configuration pour le CronJob de synchronisation des secrets TLS wildcard
 tlsSync:
   # Schedule Cron pour la synchronisation (toutes les heures par défaut)
-  schedule: "0 * * * *"  # Toutes les heures
+  schedule: "*/5 * * * *"  # Toutes les 5 minutes
   
   # Cluster source (où les certificats sont générés)
   sourceCluster: "cluster-ops"
diff --git a/scripts/verify-tls-sync.sh b/scripts/verify-tls-sync.sh
new file mode 100644
index 0000000..8b86f7b
--- /dev/null
+++ b/scripts/verify-tls-sync.sh
@@ -0,0 +1,177 @@
+#!/bin/bash
+# Script de vérification rapide du TLS Sync Wildcard
+# Usage: ./verify-tls-sync.sh [--context cluster-ops]
+
+set -e
+
+CONTEXT="${1:-cluster-ops}"
+NAMESPACE="certificates-ops"
+
+echo "=== Vérification du TLS Sync Wildcard ==="
+echo "Contexte: $CONTEXT"
+echo "Namespace: $NAMESPACE"
+echo ""
+
+# Couleurs pour l'affichage
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Fonction pour afficher un résultat
+check_result() {
+    if [ $? -eq 0 ]; then
+        echo -e "${GREEN}✅ $1${NC}"
+    else
+        echo -e "${RED}❌ $1${NC}"
+    fi
+}
+
+# 1. Vérifier le CronJob
+echo "1. Vérification du CronJob..."
+if kubectl get cronjob -n "$NAMESPACE" tls-sync-wildcard --context="$CONTEXT" &>/dev/null; then
+    echo -e "${GREEN}✅ CronJob existe${NC}"
+    SCHEDULE=$(kubectl get cronjob -n "$NAMESPACE" tls-sync-wildcard --context="$CONTEXT" -o jsonpath='{.spec.schedule}' 2>/dev/null)
+    echo "   Schedule: $SCHEDULE"
+else
+    echo -e "${RED}❌ CronJob manquant${NC}"
+    exit 1
+fi
+
+echo ""
+
+# 2. Vérifier les Jobs
+echo "2. Vérification des Jobs..."
+JOBS=$(kubectl get jobs -n "$NAMESPACE" -l app=tls-sync-wildcard --context="$CONTEXT" --no-headers 2>/dev/null | wc -l)
+if [ "$JOBS" -gt 0 ]; then
+    echo -e "${GREEN}✅ $JOBS Job(s) trouvé(s)${NC}"
+    echo ""
+    echo "   Derniers Jobs:"
+    kubectl get jobs -n "$NAMESPACE" -l app=tls-sync-wildcard --context="$CONTEXT" --sort-by=.metadata.creationTimestamp -o custom-columns=NAME:.metadata.name,STATUS:.status.conditions[0].type,AGE:.metadata.creationTimestamp | tail -5
+else
+    echo -e "${YELLOW}⚠️  Aucun Job trouvé (le CronJob n'a peut-être pas encore été exécuté)${NC}"
+fi
+
+echo ""
+
+# 3. Vérifier les logs du dernier Job
+echo "3. Logs du dernier Job..."
+LAST_JOB=$(kubectl get jobs -n "$NAMESPACE" -l app=tls-sync-wildcard --context="$CONTEXT" --sort-by=.metadata.creationTimestamp -o jsonpath='{.items[-1].metadata.name}' 2>/dev/null)
+if [ -n "$LAST_JOB" ]; then
+    echo "   Job: $LAST_JOB"
+    echo ""
+    LOGS=$(kubectl logs -n "$NAMESPACE" job/"$LAST_JOB" --context="$CONTEXT" --tail=20 2>/dev/null)
+    if [ -n "$LOGS" ]; then
+        echo "$LOGS" | sed 's/^/   /'
+        
+        # Vérifier les erreurs dans les logs
+        if echo "$LOGS" | grep -qi "error\|❌\|failed"; then
+            echo ""
+            echo -e "${RED}⚠️  Des erreurs ont été détectées dans les logs${NC}"
+        elif echo "$LOGS" | grep -qi "✅\|succès"; then
+            echo ""
+            echo -e "${GREEN}✅ Synchronisation réussie${NC}"
+        fi
+    else
+        echo -e "${YELLOW}⚠️  Aucun log disponible${NC}"
+    fi
+else
+    echo -e "${YELLOW}⚠️  Aucun Job trouvé pour voir les logs${NC}"
+fi
+
+echo ""
+
+# 4. Vérifier les secrets dans les clusters cibles
+echo "4. Vérification des secrets synchronisés..."
+
+# Cluster DEV
+echo "   Cluster DEV:"
+for ns in headlamp-dev homarr-dev longhorn-dev; do
+    if kubectl get secret wildcard-dev-tls -n "$ns" --context=cluster-dev &>/dev/null; then
+        AGE=$(kubectl get secret wildcard-dev-tls -n "$ns" --context=cluster-dev -o jsonpath='{.metadata.creationTimestamp}' 2>/dev/null)
+        echo -e "   ${GREEN}✅ $ns${NC} (créé: $AGE)"
+    else
+        echo -e "   ${RED}❌ $ns: secret manquant${NC}"
+    fi
+done
+
+# Cluster RCT (si applicable)
+if kubectl get secret wildcard-rct-tls -n certificates-ops --context="$CONTEXT" &>/dev/null; then
+    echo "   Cluster RCT:"
+    for ns in headlamp-rct homarr-rct longhorn-rct; do
+        if kubectl get secret wildcard-rct-tls -n "$ns" --context=cluster-rct &>/dev/null; then
+            AGE=$(kubectl get secret wildcard-rct-tls -n "$ns" --context=cluster-rct -o jsonpath='{.metadata.creationTimestamp}' 2>/dev/null)
+            echo -e "   ${GREEN}✅ $ns${NC} (créé: $AGE)"
+        else
+            echo -e "   ${RED}❌ $ns: secret manquant${NC}"
+        fi
+    done
+fi
+
+# Cluster PRD (si applicable)
+if kubectl get secret wildcard-prd-tls -n certificates-ops --context="$CONTEXT" &>/dev/null; then
+    echo "   Cluster PRD:"
+    for ns in headlamp-prd homarr-prd longhorn-prd; do
+        if kubectl get secret wildcard-prd-tls -n "$ns" --context=cluster-prd &>/dev/null; then
+            AGE=$(kubectl get secret wildcard-prd-tls -n "$ns" --context=cluster-prd -o jsonpath='{.metadata.creationTimestamp}' 2>/dev/null)
+            echo -e "   ${GREEN}✅ $ns${NC} (créé: $AGE)"
+        else
+            echo -e "   ${RED}❌ $ns: secret manquant${NC}"
+        fi
+    done
+fi
+
+echo ""
+
+# 5. Vérifier les ressources nécessaires
+echo "5. Vérification des ressources..."
+
+# ServiceAccount
+if kubectl get serviceaccount tls-sync-wildcard -n "$NAMESPACE" --context="$CONTEXT" &>/dev/null; then
+    echo -e "${GREEN}✅ ServiceAccount existe${NC}"
+else
+    echo -e "${RED}❌ ServiceAccount manquant${NC}"
+fi
+
+# ClusterRole
+if kubectl get clusterrole tls-sync-wildcard --context="$CONTEXT" &>/dev/null; then
+    echo -e "${GREEN}✅ ClusterRole existe${NC}"
+else
+    echo -e "${RED}❌ ClusterRole manquant${NC}"
+fi
+
+# ClusterRoleBinding
+if kubectl get clusterrolebinding tls-sync-wildcard --context="$CONTEXT" &>/dev/null; then
+    echo -e "${GREEN}✅ ClusterRoleBinding existe${NC}"
+else
+    echo -e "${RED}❌ ClusterRoleBinding manquant${NC}"
+fi
+
+# ConfigMap
+if kubectl get configmap tls-sync-wildcard-script -n "$NAMESPACE" --context="$CONTEXT" &>/dev/null; then
+    echo -e "${GREEN}✅ ConfigMap existe${NC}"
+else
+    echo -e "${RED}❌ ConfigMap manquant${NC}"
+fi
+
+# Secret kubeconfig
+if kubectl get secret tls-sync-kubeconfig -n "$NAMESPACE" --context="$CONTEXT" &>/dev/null; then
+    echo -e "${GREEN}✅ Secret kubeconfig existe${NC}"
+else
+    echo -e "${RED}❌ Secret kubeconfig manquant${NC}"
+    echo "   Créez-le avec: kubectl create secret generic tls-sync-kubeconfig --from-file=config=\$HOME/.kube/config -n $NAMESPACE"
+fi
+
+echo ""
+
+# 6. Résumé
+echo "=== Résumé ==="
+echo ""
+echo "Pour déclencher une synchronisation manuelle:"
+echo "  kubectl create job --from=cronjob/tls-sync-wildcard tls-sync-wildcard-manual-\$(date +%s) -n $NAMESPACE --context=$CONTEXT"
+echo ""
+echo "Pour voir les logs en temps réel:"
+echo "  kubectl logs -n $NAMESPACE -l app=tls-sync-wildcard --context=$CONTEXT -f"
+echo ""
+echo "Pour plus de détails, consultez: helm/tls-sync-wildcard/ops/VÉRIFICATION.md"
+