diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index cd5854e820..30c9df78ec 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -8,5 +8,5 @@
 - [ ] This PR does not contain plagiarism
   - don’t copy other people’s work unless you are quoting and contributing it to them.
 - [ ] I have signed off on all commits 
-  - [signing off](https://docs.github.com/en/authentication/managing-commit-signature-verification/signing-commits) (ex: `git commit -s`) is to affirm that commits comply [DCO](https://wiki.linuxfoundation.org/dco).
+  - [signing off](https://docs.github.com/en/authentication/managing-commit-signature-verification/signing-commits) (ex: `git commit -s`) is to affirm that commits comply [DCO](https://wiki.linuxfoundation.org/dco). If you are working locally, you could add an alias to your `gitconfig` by running `git config --global alias.ci "commit -s"`.
     
diff --git a/.github/settings.yml b/.github/settings.yml
index cf7eefd021..469f786985 100644
--- a/.github/settings.yml
+++ b/.github/settings.yml
@@ -43,7 +43,7 @@ collaborators:
   # Localization approvers
   # l10n ko approvers
   # Note: seokho-son is both Maintainer (maintain) and Korean approver (push)
-  # Note: jihoon-seo is both English approver (push) and Korean approver (push)
+  # Note: jihoon-seo is both Maintainer (maintain) and Korean approver (push)
   - username: Eviekim
     permission: push
 
@@ -78,15 +78,18 @@ collaborators:
 
   # l10n de approvers
   # Note: CathPag is both Maintainer (maintain) and de approver (push)
-  # Note: iamNoah1 is both English approver (push) and de approver (push)
+  # Note: iamNoah1 is both Maintainer (maintain) and de approver (push)
   - username: DaveVentura
     permission: push
+    
+  - username: bcubk
+    permission: push
 
   # l10n it approvers
   - username: fsbaraglia
     permission: push
 
-  - username: meryem-ldn
+  - username: ugho16
     permission: push
 
   - username: annalisag-spark
@@ -258,6 +261,7 @@ branches:
         users:
          - iamNoah1
          - DaveVentura
+         - bcubk
         teams: []
       enforce_admins: null
       required_linear_history: null
@@ -274,7 +278,7 @@ branches:
         # it approvers
         users:
          - fsbaraglia
-         - meryem-ldn
+         - ugho16
          - annalisag-spark
          - sistella
         teams: []
diff --git a/.github/workflows/check-outdated-terms.yaml b/.github/workflows/check-outdated-terms.yaml
new file mode 100644
index 0000000000..31fccf6616
--- /dev/null
+++ b/.github/workflows/check-outdated-terms.yaml
@@ -0,0 +1,131 @@
+# This workflow will check if localized terms are outdated or not
+# by comparing English terms in the old branch and the latest branch.
+name: Check outdated terms
+on: 
+  pull_request:
+    paths:
+      - 'content/en/**.md'
+    branches:
+      - 'dev-ko' # add other branches or use wildcard 'dev-**'
+
+jobs:
+  check-outdated-terms:
+    name: Check outdated terms
+    
+    # Condition to run this workflow on the upstream repository
+    #if: github.repository == 'cncf/glossary'
+    
+    runs-on: ubuntu-latest
+    # permissions:
+    #   issues: write
+    
+    # NOTE - In this workflow, "github.base_ref" refers to the old upstream/dev-xx.
+    # NOTE - In this workflow, "github.head_ref" refers to the latest forked/dev-xx or the latest upstream/main.
+    steps:
+    - name: Set up environment variables for the target L10n team
+      shell: bash
+      run: |
+        
+        # Set L10n branch
+        L10N_BRANCH="${{github.base_ref}}"
+        echo "(DEBUG) L10N Branch: ${L10N_BRANCH}"
+        
+        # Set L10n directory and code
+        case "${L10N_BRANCH}" in
+          dev-ko)          
+          L10N_DIR="./content/ko/"
+          L10N_CODE="ko"
+          ;;
+          
+          #dev-pt)
+          #L10N_DIR="./content/pt-br/"
+          #L10N_CODE="pt"
+          #;;
+        esac
+        
+        echo "(DEBUG) L10N Directory: ${L10N_DIR}"
+        echo "(DEBUG) L10N Code: ${L10N_CODE}"
+        
+        # Set L10N_DIR and L10N_CODE as environment variables
+        # Ref: https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#setting-an-environment-variable
+        echo "L10N_DIR=${L10N_DIR}" >> $GITHUB_ENV
+        echo "L10N_CODE=${L10N_CODE}" >> $GITHUB_ENV        
+    
+    - name: Checkout 
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 0 # fetch all history for all tags and branches
+        
+    - name: Check outdated
+      id: checker
+      shell: bash
+      run: |
+        ##### DEBUG section, this will be removed later ###########
+        ls -al
+        git status
+        git branch
+        
+        # Default environment variables 
+        echo "GITHUB_REF: $GITHUB_REF"
+        echo "Extract branch: ${GITHUB_REF#refs/}"
+        
+        # `github` context information
+        echo "(DEBUG) github.ref: ${{github.ref}}"
+        echo "(DEBUG) github.head_ref: ${{github.head_ref}}"
+        echo "(DEBUG) github.base_ref: ${{github.base_ref}}"
+        echo "(DEBUG) L10N_DIR: ${L10N_DIR}"
+        echo "(DEBUG) L10N_DIR: ${{ env.L10N_DIR }}"
+        #####################################################
+        
+        # Get the lastest branch name from 'GITHUB_REF' 
+        # The latest branch can be 'upstream/main' or 'forked/dev-ko' (rebased)
+        LATEST_BRANCH=${GITHUB_REF#refs/}
+        echo "(DUBUG) LATEST_BRANCH: ${LATEST_BRANCH}"
+        
+        # Get the old branch from 'github.base_ref' 
+        # The old branch can be 'upstream/dev-ko'
+        OLD_BRANCH="origin/${{github.base_ref}}"
+        echo "(DUBUG) OLD_BRANCH: ${OLD_BRANCH}"
+        
+        # Make an output directory
+        mkdir outdated
+        
+        # Check outdated only if there is a localized term
+        # Loop files in a localization directory, which is ${L10N_DIR} (e.g., ./content/ko/)
+        echo "(DEBUG) Check outdated"
+        for FILE_PATH in $(find ${L10N_DIR} -name '*.md'); do
+            # ${MYVAR#pattern}: delete shortest match of pattern from the beginning
+            FILE_NAME="${FILE_PATH#${L10N_DIR}}" 
+            echo "(DEBUG) FILE_NAME: ${FILE_NAME}"
+            echo "(DEBUG) Localized file path: $FILE_PATH"
+            echo "(DEBUG) Original file path: ./content/en/${FILE_NAME}"
+            
+            # Actually compare between the old and lastest English terms and log diff in the file
+            if [[ -f "./content/en/${FILE_NAME}" ]]; then
+              # File exists
+              git diff ${OLD_BRANCH}..${LATEST_BRANCH} -- ./content/en/${FILE_NAME} > ./outdated/${FILE_NAME}
+            else
+              # File dose not exist (e.g, changed, renamed or removed)
+              echo "Could not find ${FILE_NAME} in content/en/" > ./outdated/${FILE_NAME}
+              echo "Need to check if it has been changed, renamed or removed" >> ./outdated/${FILE_NAME}
+            fi
+
+        done 
+        
+        echo "(DEBUG) The outdated files"
+        ls -al ./outdated
+        
+    - name: Upload output
+      uses: actions/upload-artifact@v3
+      with:
+        name: ${{ env.L10N_CODE }}-outdated-checking-result
+        path: ./outdated/
+
+#     - name: Create an issue from file    
+#       uses: peter-evans/create-issue-from-file@v4
+#       with:
+#         title: An example issue
+#         content-filepath:  ${{ steps.checker.outputs.output_path }}
+#         labels: |
+#           outdated
+#           lang/ko
diff --git a/.github/workflows/es-spellcheck.yml b/.github/workflows/es-spellcheck.yml
index 1c0c087445..a08c3dda08 100644
--- a/.github/workflows/es-spellcheck.yml
+++ b/.github/workflows/es-spellcheck.yml
@@ -24,7 +24,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
+      - name: Check word list sort
+        run: |
+          set -o errexit
+          diff content/es/.wordlist.txt <(LC_ALL= sort -f content/es/.wordlist.txt)
       - name: GitHub Spellcheck Action
-        uses: rojopolis/spellcheck-github-actions@0.27.0
+        uses: rojopolis/spellcheck-github-actions@0.28.0
         with:
           config_path: content/es/.spellcheck.yml
diff --git a/.github/workflows/post-outdated-terms-report.yaml b/.github/workflows/post-outdated-terms-report.yaml
new file mode 100644
index 0000000000..6a49b7328f
--- /dev/null
+++ b/.github/workflows/post-outdated-terms-report.yaml
@@ -0,0 +1,130 @@
+# This workflow will post outdated terms report
+# by using data from previous workflows. 
+name: Post outdated terms report
+
+on:
+  workflow_run:
+    workflows: ["Check outdated terms"]
+    types:
+      - completed
+      
+jobs:
+  post-outdated-report:
+    name: Post outdated terms report
+    
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write 
+#       pull-requests: write
+
+    steps:    
+    - name: Show the github context
+      shell: bash
+      run: |
+        echo "(DEBUG) ParsedBranch: ${GITHUB_REF#refs/heads/}"
+        echo "(DEBUG) github: ${{ github }}"
+        echo "(DEBUG) toJSON(github):" 
+        echo '${{ toJSON(github) }}'
+        echo "(DEBUG) github.action: ${{ github.action }}"
+        echo "(DEBUG) github.action_path: ${{ github.action_path }}"
+        echo "(DEBUG) github.actor: ${{ github.actor }}"
+        echo "(DEBUG) github.base_ref: ${{ github.base_ref	}}"
+        echo "(DEBUG) github.event: ${{ github.event }}"
+        echo "(DEBUG) github.event_name: ${{ github.event_name }}"
+        echo "(DEBUG) github.event_path: ${{ github.event_path }}"
+        echo "(DEBUG) github.head_ref: ${{ github.head_ref }}"
+        echo "(DEBUG) github.job: ${{ github.job }}"
+        echo "(DEBUG) github.ref: ${{ github.ref }}"
+        echo "(DEBUG) github.repository: ${{ github.repository }}"
+        echo "(DEBUG) github.repository_owner: ${{ github.repository_owner }}"
+        echo "(DEBUG) github.run_id: ${{ github.run_id }}"
+        echo "(DEBUG) github.run_number: ${{ github.run_number }}"
+        echo "(DEBUG) github.sha: ${{ github.sha }}"
+        echo "(DEBUG) github.token: ${{ github.token }}"
+        echo "(DEBUG) github.workflow: ${{ github.workflow }}"
+        echo "(DEBUG) github.workspace: ${{ github.workspace }}"
+        
+#     NOTE - "actions/download-artifact" is not working for sharing data between workflows. 
+#     - name: Download output
+#       uses: actions/download-artifact@v3
+    - name: Download output
+      uses: dawidd6/action-download-artifact@v2
+      with:
+        github_token: ${{secrets.GITHUB_TOKEN}}
+        workflow: check-outdated-terms.yaml
+        workflow_conclusion: success
+        
+    - name: Set up environment variables from the output
+      shell: bash
+      run: |
+        echo "(DEBUG) Display files and directories"
+        tree
+        
+        # Set the last changed directory as the output directory
+        OUTPUT_DIR=$(ls -tp | head -1)
+        
+        # Extract L10N code from the directory name
+        # ${MYVAR%%-*}: retain the part before the first '-'
+        L10N_CODE=${OUTPUT_DIR%%-*}
+        
+        # Count outdated terms 
+        OUTDATED_TERMS_COUNT=$(ls $OUTPUT_DIR | wc -l)
+        
+        echo "(DEBUG) OUTPUT_DIR: ${OUTPUT_DIR}"
+        echo "(DEBUG) L10N_CODE: ${L10N_CODE}"
+        echo "(DEBUG) OUTDATED_TERMS_COUNT: ${OUTDATED_TERMS_COUNT}"
+        
+        # Set OUTPUT_DIR, L10N_CODE, and OUTDATED_TERMS_COUNT as environment variables
+        # Ref: https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#setting-an-environment-variable
+        echo "OUTPUT_DIR=${OUTPUT_DIR}" >> $GITHUB_ENV
+        echo "L10N_CODE=${L10N_CODE}" >> $GITHUB_ENV
+        echo "OUTDATED_TERMS_COUNT=${OUTDATED_TERMS_COUNT}" >> $GITHUB_ENV
+        
+    - name: Generate a report markdown
+      if: ${{ env.OUTDATED_TERMS_COUNT > 0 }}
+      shell: bash
+      run: |
+        FILE_LIST=$(find ${OUTPUT_DIR} -name '*.md')
+        
+        # Create report.md
+        touch report.md
+        
+        # Generate markdown
+        echo "NOTICE - The following outdated terms must be resolved before the next L10n branch updates." >> report.md
+        echo "" >> report.md
+        echo "### Outdated files" >> report.md
+        
+        for FILE in ${FILE_LIST}; do 
+          FILE_NAME="${FILE#${OUTPUT_DIR}}" 
+          echo "- ${FILE_NAME}" >> report.md
+        done 
+        
+        echo "" >> report.md
+        
+        echo "### Details" >> report.md
+        
+        for FILE in ${FILE_LIST}; do 
+          FILE_NAME="${FILE#${OUTPUT_DIR}}" 
+
+          echo "Outdated file: ${FILE_NAME}" >> report.md
+          echo "" >> report.md
+          echo "\`\`\`diff" >> report.md 
+          cat ${FILE} >> report.md      
+          echo "\`\`\`" >> report.md 
+          echo "" >> report.md
+          
+        done 
+        
+        echo "The end of report"  >> report.md
+        
+    - name: Create an issue from the report
+      uses: peter-evans/create-issue-from-file@v4
+      with:
+        title: "[${{ env.L10N_CODE }}] A report to track update"
+        content-filepath: report.md
+        labels: |
+          outdated
+          good first issue
+          lang/${{ env.L10N_CODE }}
diff --git a/.github/workflows/spellcheck.yml b/.github/workflows/spellcheck.yml
index a1be0bcb75..dfa9396445 100644
--- a/.github/workflows/spellcheck.yml
+++ b/.github/workflows/spellcheck.yml
@@ -25,4 +25,4 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: GitHub Spellcheck Action
-        uses: rojopolis/spellcheck-github-actions@0.27.0
+        uses: rojopolis/spellcheck-github-actions@0.28.0
diff --git a/CODEOWNERS b/CODEOWNERS
index 9642fcac3e..ed449ab642 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -22,10 +22,10 @@
 /content/hi/ @Garima-Negi @sayantani11 @anubha-v-ardhan @jayesh-srivastava
 
 # Approvers for German contents
-/content/de/ @iamNoah1 @DaveVentura @CathPag
+/content/de/ @iamNoah1 @DaveVentura @CathPag @bcubk
 
 # Approvers for Italian contents
-/content/it/ @fsbaraglia @meryem-ldn @annalisag-spark @sistella
+/content/it/ @fsbaraglia @ugho16 @annalisag-spark @sistella
 
 # Approvers for Arabic contents
 /content/ar/ @TarekMSayed @same7ammar @AShabana @arezk84
diff --git a/config.toml b/config.toml
index dbe0c05247..d2fe9000d1 100644
--- a/config.toml
+++ b/config.toml
@@ -109,7 +109,6 @@ languageName ="中文(Chinese)"
 contentDir = "content/zh-cn"
 weight = 7
 
-
 [languages.bn]
 title = "ক্লাউড নেটিভ শব্দকোষ"
 description = "CNCF ক্লাউড নেটিভ শব্দকোষ প্রকল্পটি ক্লাউড নেটিভ অ্যাপ্লিকেশন সম্পর্কে কথা বলার সময় ব্যবহৃত সাধারণ পদগুলির জন্য একটি রেফারেন্স হিসাবে ব্যবহার করার উদ্দেশ্যে।"
@@ -117,6 +116,13 @@ languageName = "বাংলা(Bengali)"
 contentDir = "content/bn"
 weight = 8
 
+[languages.de]
+title = "Cloud Native Glossar"
+description = "Das CNCF Cloud Native Glossar soll als Referenz für gängige Begriffe dienen, die im Zusammenhang mit Cloud Native Anwendungen verwendet werden."
+languageName ="Deutsch"
+contentDir = "content/de"
+weight = 9
+
 
 [markup]
   [markup.goldmark]
diff --git a/content/bn/_index.md b/content/bn/_index.md
index 19c1ba1196..daee43d421 100644
--- a/content/bn/_index.md
+++ b/content/bn/_index.md
@@ -1,5 +1,6 @@
 ---
 title: "ক্লাউড নেটিভ শব্দকোষ"
+status: Completed
 ---
 
 # ক্লাউড নেটিভ শব্দকোষ
diff --git a/content/de/_index.md b/content/de/_index.md
new file mode 100644
index 0000000000..942809f59d
--- /dev/null
+++ b/content/de/_index.md
@@ -0,0 +1,28 @@
+
+---
+title: "Cloud Native Glossar"
+status: Completed
+---
+
+# Cloud Native Glossar
+
+Das Cloud Native Glossar ist ein Projekt unter der Leitung des CNCF Business Value Subcommittee (BVS). Das Ziel ist es, Cloud Native Konzepte in klarer und einfacher Sprache zu erklären, ohne dass technische Vorkenntnisse erforderlich sind.
+
+## Mitwirken
+Jede/r ist eingeladen, Änderungen, Ergänzungen und Verbesserungen für das Cloud Native Glossar vorzuschlagen. Wir verwenden einen Community-gesteuerten Prozess, der von der CNCF geregelt wird, um dieses gemeinsame Lexikon zu entwickeln und zu verbessern. Dieses Glossar bietet eine herstellerneutrale Plattform, um ein gemeinsames Vokabular rund um Cloud Native-Technologien zu organisieren. Beiträge sind von allen Teilnehmern willkommen, die sich an den Zweck und die Ziele des Projekts halten.
+
+Jede/r, der/die einen Beitrag leisten möchte, kann ein GitHub Issue eröffnen oder einen Pull Request erstellen. Dazu sollte man zunächst [dieses Dokument](/contribute/) lesen, sich mit dem einzuhaltenden [Style Guide](/style-guide/) vertraut machen und dem #glossary Kanal in dem CNCF Slack Workspace beitreten. Es gibt auch einen #glossary-localizations Kanal für diejenigen, die helfen wollen, das Glossar in ihre Muttersprache zu übersetzen.
+
+
+## Danksagung
+
+Das Cloud Native Glossar wurde vom CNCF Marketing
+Committee (Business Value Subcommittee) initiiert und enthält
+Beiträge von [Catherine Paganini](https://www.linkedin.com/in/catherinepaganini/en/), [Chris Aniszczyk](https://www.linkedin.com/in/caniszczyk/),
+[Daniel Jones](https://www.linkedin.com/in/danieljoneseb/?originalSubdomain=uk), [Jason Morgan](https://www.linkedin.com/in/jasonmorgan2/), [Katelin Ramer](https://www.linkedin.com/in/katelinramer/), [Mike Foster](https://www.linkedin.com/in/mfosterche/?originalSubdomain=ca), [Seokho Son](https://www.linkedin.com/in/seokho-son/) und vielen weiteren Mitwirkenden. Eine vollständige Liste der Mitwirkenden befindet sich auf [dieser GitHub-Seite](https://github.com/cncf/glossary/graphs/contributors).
+
+Die deutsche Version enthält Beiträge von [David Wagner](https://www.linkedin.com/in/david-wagner-dataone/), [Baris Cubukcuoglu](https://www.linkedin.com/in/baris-cubukcuoglu-4165641a9/) und [Noah Ispas](https://www.linkedin.com/in/noah-ispas-0665b42a/).
+
+## Lizenz
+
+Alle Codebeiträge stehen unter der Apache 2.0 Lizenz. Die Dokumentation wird unter CC BY 4.0 verbreitet.
diff --git a/content/de/abstraction.md b/content/de/abstraction.md
new file mode 100644
index 0000000000..706271b845
--- /dev/null
+++ b/content/de/abstraction.md
@@ -0,0 +1,17 @@
+---
+title: Abstraktion
+status: Completed
+category: Eigenschaft
+---
+
+Mit Hilfe von Abstraktionen werden spezifische Gegebenheiten von IT–Systemen vor dem Nutzer verborgen.
+Dadurch schaffen Abstraktionen generische Lösungen, die einfacher zu verstehen sind.
+
+Ein gutes Beispiel hierfür ist das Betriebssystem auf deinem Laptop.
+Als Laptop-Nutzer musst du kein tiefergehendes Verständnis von CPUs, Speicher und Software haben.
+Dein Betriebssystem abstrahiert das komplexe Zusammenspiel aus Computer Hardware und Software von der Nutzerschicht.
+
+IT-Systeme haben typischerweise mehrere Abstraktionsschichten.
+Das vereinfacht die Entwicklung von Software.
+Softwareentwickler programmieren eine Softwarekomponente gegen eine bestimmte Abstraktionsschicht.
+Ähnlich wie der Laptopnutzer muss sich der Softwareentwickler dadurch nicht mit komplexen Gegebenheiten unterhalb der Abstraktionsschicht auseinandersetzen.
\ No newline at end of file
diff --git a/content/de/agile-software-development.md b/content/de/agile-software-development.md
new file mode 100644
index 0000000000..122aa595b8
--- /dev/null
+++ b/content/de/agile-software-development.md
@@ -0,0 +1,27 @@
+---
+title: Agile Softwareentwicklung
+status: Completed
+category: Konzept
+---
+
+## Was es ist
+
+Agile Softwareentwicklung beschreibt ein Vorgehensmodell der Softwareentwicklung, 
+bei der die Arbeit in Iterationen und selbstorganisierte Teams im Vordergrund stehen. 
+Im Vergleich zu wasserfallartigen Projekten, bei denen die Ergebnisse erst am Ende eines Projekts entstehen, 
+liegt der Fokus der agilen Sofwareentwicklung auf einer kontinuierlichen Bereitstellung von Software-Inkrementen 
+und ständiger Verbesserung des Prozesses. 
+
+## Welches Problem es löst
+
+Das Kommunizieren und Verstehen der Anforderungen eines Softwareprojekts ist ein sehr schweres, wenn nicht sogar unmögliches Unterfangen. 
+Dennoch wollen Kunden meist, dass Softwareprojekte in einem fest definierten Umfang, im Rahmen eines festen Budgets, pünktlich und hoher Qualität fertiggestellt werden. 
+Der zyklische Charakter agiler Softwareentwicklung ermöglicht eine bessere Anpassung der Anforderung 
+oder generell an die Veränderung diverser Umstände, als wasserfallartige Vorgehensweisen es tun.  
+
+## Wie es das Problem löst
+
+Alle Phasen traditioneller (wasserfallartiger) Vorgehensmodelle wie etwa Anforderungsmanagement, Planung, Implementierung, Test und Auslieferung sind in der agilen Softwareentwicklung gleichermaßen vorgesehen. 
+Allerdings, und das ist der größte Unterschied, ist die gesamte Zeitspanne eines Softwareprojekts in Iterationen unterteilt, die jeweils alle diese Phasen enthalten. 
+Nach jeder Iteration kann ein erschaffenes Software-Inkrement zusammen mit dem Kunden überprüft sowie Anforderungen angepasst werden. 
+Weiterhin erhält das Entwicklungsteam die Chance, über den Prozess selbst zu reflektieren und konkrete Handlungen für Verbesserungen abzuleiten.
\ No newline at end of file
diff --git a/content/de/api-gateway.md b/content/de/api-gateway.md
new file mode 100644
index 0000000000..ccd65e5e56
--- /dev/null
+++ b/content/de/api-gateway.md
@@ -0,0 +1,30 @@
+---
+title: API Gateway
+status: Completed
+category: Technologie
+---
+
+## Was es ist
+
+Ein [API](/application-programming-interface/) Gateway ist ein Werkzeug zur Zusammenfassung einzelner
+Applikations APIs an einem einzigen Ort. Es erlaubt Organisationen Kernfunktionen wie 
+Authentifikation, Autorisation oder auch die Limitierung von Anfragen zentral zu managen.
+Ein API Gateway stellt somit eine einheitliche Schnittstelle für - zumeist externe - API 
+Benutzer zur Verfügung.
+
+## Welches Problem es löst
+
+Stellt man externen Nutzern [API](/application-programming-interface/)s zur Verfügung,
+ist es wünschenswert, den Zugriff darauf an zentraler Stelle verwalten zu können. Zusätzlich
+erlaubt eine solche Lösung, jeder API Interaktion zusätzliche Funktionalität hinzuzufügen,
+ohne dafür den Quellcode verändern zu müssen.
+
+## Wie es das Problem löst
+
+Verschiedene Schnittstellen einer Applikation zentral zu bündeln, erleichtert es
+Organisationen vertikale Geschäftslogiken oder Sicherheitsfunktionen an einem Ort zu verwalten.
+Für Benutzer der Schnittstellen bietet sich der Vorteil einen einzigen Endpunkt für alle Belange
+nutzen zu können. Ein API Gateway kann helfen administrative Herausforderungen wie Sicherheit oder
+Sichtbarkeit durch Zentralisierung zu vereinfachen. Da alle Anfragen durch den API Gateway
+fließen, ist es die ideale Stelle, um Funktionen für die Sammlung von Metriken, Rate Limiting
+sowie Authentifikation und Autorisierung zur Verfügung zu stellen.
diff --git a/content/de/application-programming-interface.md b/content/de/application-programming-interface.md
new file mode 100644
index 0000000000..f077e68417
--- /dev/null
+++ b/content/de/application-programming-interface.md
@@ -0,0 +1,23 @@
+---
+title: Application Programming Interface
+status: Completed
+category: Technologie
+---
+
+## Was es ist
+
+APIs regeln die Kommunikation zwischen Softwareanwendungen.
+Im weiteren Sinne kann man das mit einem Gespräch zwischen zwei Personen vergleichen.
+In diesem Beispiel wäre eine API die konkrete Sprache, die gesprochen wird.
+Im Gegensatz zu einem Gespräch zwischen zwei Personen ist die Kommunikation zwischen Softwareanwendungen allerdings eingeschränkt.
+Sie unterliegt einem gewissen Standard, bei dem die Sprache und die Kanäle der Kommunikation festgelegt sind.
+
+## Welches Problem es löst
+
+Softwareanwendungen können mit der Zeit sehr komplex werden und kleine Änderungen an einer Stelle der Anwendung können fundamentale Auswirkungen auf andere Bereiche der Anwendung haben.
+Um die wachsende Komplexität zu beherrschen werden verschiedene Bereiche voneinander durch Modularisierung entkoppelt oder abstrahiert. Der Grad der Modularisierung kann dabei von internen Bereichen innerhalb einer Anwendung, bis hin zu einer eigenständigen Anwendung reichen (siehe [verteilten Anwendung](/distributed-apps/)). In beiden Fällen jedoch wird eine Standardisierung benötigt, die beschreibt wie, die einzelnen Anwendungen oder Anwendungsbereiche miteinander kommunizieren können. 
+
+## Wie es das Problem löst
+
+Eine API beschreibt, wie zwei oder mehrere Anwendungen miteinander kommunizieren können. Dabei werden die Kanäle beschrieben sowie die Sprache der Kommunikation (Ein und Ausgabe von Daten). 
+APIs sind die Bausteine moderner Applikationen. Sie fördern die Wiederverwendbarkeit und Wartbarkeit einer Anwendung. [Microservices](/microservices/) beispielsweise kommunizieren oftmals über APIs miteinander. 
\ No newline at end of file
diff --git a/content/de/autoscaling.md b/content/de/autoscaling.md
new file mode 100644
index 0000000000..cc8a639378
--- /dev/null
+++ b/content/de/autoscaling.md
@@ -0,0 +1,24 @@
+---
+title: Autoskalierung
+status: Completed
+category: Konzept
+---
+
+## Was es ist
+
+Autoskalierung ist die Fähigkeit eines Systems, automatisch zu skalieren, typischerweise in Bezug auf die Rechenressourcen.
+Bei einem System mit automatischer Skalierung werden Ressourcen bei Bedarf automatisch hinzugefügt, um schwankenden Nutzeranforderungen gerecht zu werden. 
+Der Prozess der Autoskalierung variiert und ist so konfigurierbar, dass die Skalierung auf der Grundlage verschiedener Metriken, wie z.B. Speicher oder Prozesszeit, erfolgt.
+
+## Welches Problem es löst
+
+Früher waren die Infrastruktur und die Anwendungen auf ein Maximum an Auslastung ausgelegt.
+Diese Architektur bedeutete, dass mehr Ressourcen nicht ausgelastet waren und nicht flexibel auf die sich ändernde Verbrauchernachfrage reagieren konnten.
+Diese fehlende Flexibilität bedeutete höhere Kosten, sowie Geschäftseinbußen durch Ausfälle aufgrund von Übernachfrage. 
+
+## Wie es das Problem löst
+
+Durch die Nutzung der Cloud, die Virtualisierung und Containerisierung von Anwendungen und deren Abhängigkeiten können Unternehmen Anwendungen erstellen, die entsprechend den Benutzeranforderungen skaliert werden können.
+Sie können die Anwendungsnachfrage überwachen und sie automatisch skalieren, um ein optimale User Experience zu bieten.
+Ein Beispiel ist der Anstieg der Zuschauerzahlen, den Netflix jeden Freitagabend erlebt.
+Automatische Skalierung bedeutet, dass dynamisch mehr Ressourcen hinzugefügt werden: z. B. die Anzahl der Server erhöht wird, um mehr Videostreaming zu ermöglichen, und die Ressourcen verringert werden, sobald sich der Verbrauch normalisiert hat.
\ No newline at end of file
diff --git a/content/de/blue-green-deployment.md b/content/de/blue-green-deployment.md
new file mode 100644
index 0000000000..0530d43040
--- /dev/null
+++ b/content/de/blue-green-deployment.md
@@ -0,0 +1,37 @@
+---
+title: Blue Green Deployment
+status: Completed
+category: Konzept
+tags: ["methodology", "application", ""]
+---
+
+## Was es ist
+
+Blue-Green-Deployment ist eine Strategie zur Aktualisierung von produktiven Anwendungen. 
+Der Fokus liegt darauf, Ausfallszeiten zu minimieren oder gänzlich zu vermeiden.
+In der Regel bezieht sich der Begriff Blue-Green-Deployment auf die Aktualisierung einer gesamten Anwendung
+und weniger auf die Aktualisierung einzelner Komponenten (wie etwa [Microservices](/microservices/)) 
+aus denen eine Anwendung möglicherweise besteht. 
+Um hier Verwirrungen zu vermeiden, wird für letzeres eher der Begriff "Zero-Downtime-Deployment" bevorzugt.
+
+
+## Welches Problem es löst
+
+Die Aktualisierung von Anwendungen ist üblicherweise mit Ausfallzeiten verbunden. 
+Je nach Anwendung können Ausfallszeiten allerdings gravierende Folgen haben. 
+Das Aktualisieren einzelner Komponenten einer Anwendung funktioniert leider nicht immer reibungslos. 
+Das liegt daran, dass eine Aktualisierung, 
+die Inkompatibilität einzelner Komponenten zur Folge haben kann. 
+Für solche Fälle müssen alle Komponenten der Anwendung gleichzeitig aktualisiert werden. 
+
+
+## Wie es das Problem löst
+
+Im Rahmen eines Blue-Green-Deployment werden für einen bestimmten Zeitraum zwei Umgebungen der produktiven Anwendung betrieben, 
+die jeweils als "blue" und "green" bezeichnet werden.
+Die eine Umgebung (blue) stellt die produktive Anwendung dar (die Version, die von Benutzern aktuell verwendet wird),
+während eine zweite Umgebung (green) bereitgestellt wird.
+Diese zweite Umgebung enthält eine neue Version der Anwendung.  
+Sobald die Tests in der neuen Umgebung abgeschlossen sind, 
+wird der Datenverkehr auf diese Umgebung umgelenkt (oft mit Hilfe eines [Load Balancer](/load-balancer/)).
+Im Anschluss kann die ältere Umgebung (blue) aus dem Betrieb genommen werden.
diff --git a/content/de/canary-deployment.md b/content/de/canary-deployment.md
new file mode 100644
index 0000000000..76259fd52e
--- /dev/null
+++ b/content/de/canary-deployment.md
@@ -0,0 +1,25 @@
+---
+title: Canary Deploment
+status: Completed
+category: Konzept
+---
+
+## Was es ist
+
+Das Canary-Deployment ist eine Deployment-Strategy, die bei einem neuen Release, zwei Umgebungen einbezieht: Die produktive Umgebung und eine Umgebung, welche die neue Version einer Anwendung enthält. 
+Der Datenverkehr wird nun schrittweise von der aktuell produktiven Umgebung auf die Umgebung mit der neuen Version der Anwendung gelenkt. 
+Zunächst kann damit begonnen werden, 1% des Echtzeit-Datenverkehrs zu verschieben, dann 10%, 25% und so weiter, bis der gesamte Datenverkehr über die aktualisierte Version erfolgt. 
+Unternehmen können auf diese Weise die neue Version einer Anwendung in einem Produktivsystem testen, Feedback einholen, Fehler diagnostizieren und bei Bedarf schnell ein Rollback auf die stabile Version durchführen. 
+
+Der Begriff "Canary" (Kanarienvogel) stammt aus der Praxis des "Kanarienvogels im Kohlebergwerk", bei der Kanarienvögel in Kohlebergwerke gebracht wurden, um die Bergleute zu schützen. 
+Wenn geruchlose schädliche Gase austraten, würde der Vogel sterben, und die Bergleute wussten, dass sie schnell evakuiert werden mussten. Im Falle eines Fehlers mit dem aktualisierten Code, wird der Echtzeit-Datenverkehr wieder auf die ursprüngliche Version "evakuiert".
+
+## Welches Problem es löst
+
+Unabhängig davon, wie vollständig die Teststrategie ist, werden auf Produktivsystemen immer wieder einige Fehler entdeckt. Die direkte Verlagerung des gesamten Datenverkehrs von einer aktuellen Version auf eine neue, birgt ein hohes Risiko für Fehlerfälle.  
+
+## Wie es das Problem löst
+
+Durch Canary-Deployments können Unternehmen nachvollziehen, wie sich die neue Version einer Anwendung unter realen Bedingungen verhält, bevor ein Großteil des Datenverkehrs auf die neue Version umgestellt wird.
+Diese Strategie ermöglicht es Unternehmen, Ausfallzeiten zu reduzieren und im Problemfall ein Rollback des neuen Deployments durchzuführen.
+Außerdem ermöglicht es die Durchführung tiefgreifender Tests der Produktionsanwendungen, ohne dass die Benutzerfreundlichkeit wesentlich beeinträchtigt wird.
\ No newline at end of file
diff --git a/content/de/cloud-computing.md b/content/de/cloud-computing.md
new file mode 100644
index 0000000000..712cb7c98f
--- /dev/null
+++ b/content/de/cloud-computing.md
@@ -0,0 +1,27 @@
+---
+title: Cloud Computing
+status: Completed
+category: Konzept
+---
+
+## Was es ist
+
+Das Konzept des Cloud Computing ist die Bereitstellung von Systemressourcen wie CPU, Netzwerk und Speicher auf Abruf und über das Internet.
+Cloud Computing ermöglicht den Zugriff und die Nutzung von Systemressourcen aus beliebigen Standorten.
+Diese Systemressourcen werden von Cloud-Anbietern wie AWS, GCP, Azure, Digitial Ocean und weiteren Anbietern an den Endverbraucher zur Verfügung gestellt.
+
+## Welches Problem es löst
+
+Die Skalierung von Systemressourcen stellt für viele Organisationen eine große Herausforderung dar.
+Organisationen müssen entweder fest verplante Systemressourcen bei bestehenden Rechenzentren einkaufen oder selbst ein Rechenzentrum aufbauen und verwalten.
+Hiermit sind signifikante Planungsaufwände und Kosten verbunden.
+Beim Cloud Computing verlagert sich die Verantwortung für die Bereitstellung und den Betrieb von Systemressourcen an den Cloud-Anbieter.
+
+## Wie es das Problem löst
+
+Cloud-Anbieter stellen Systemressourcen für Endnutzer auf Abruf zur Verfügung.
+Dieser Paradigmenwechsel bietet Organisationen zwei wesentliche Vorteile.
+Der reduzierte Planungsaufwand bei der Nutzung von Cloud Dienstleistungen lädt Organisationen zum Ausprobieren von neuen Ideen und Konzepten ein.
+Die daraus resultierenden Kosten und Aufwände sind überschaubar, da Endnutzer sich nicht für die Nutzung oder den Kauf von Systemressourcen langfristig verpflichten.
+Des Weiteren bieten Cloud-Anbieter eine größere Flexibilität und feinere Unterteilung von Systemressourcen durch ihr Angebot an.
+Das hilft Endnutzern dabei, den Verbrauch von Systemressourcen stärker auf ihren eigenen Bedarf abzustimmen und reduziert Kosten.
diff --git a/content/de/cloud-native-apps.md b/content/de/cloud-native-apps.md
new file mode 100644
index 0000000000..cc89fcc26a
--- /dev/null
+++ b/content/de/cloud-native-apps.md
@@ -0,0 +1,23 @@
+---
+title: Cloud Native Applikationen
+status: Completed
+category: Konzept
+---
+
+## Was es ist
+
+Cloud Native Applikationen werden auf eine Art entwickelt, welche es erlaubt die Vorteile des [Cloud Computing](/cloud-computing/) zu nutzen.
+Sie lassen sich problemlos in ihre jeweiligen Cloud-Architekturen integrieren und nutzen die Ressourcen eines Cloud Providers, sowie die verschiedenen Skalierungsmöglichkeiten der Cloud. 
+Cloud Native Anwendungen können dabei sowohl in den Rechenzentren der Cloud Provider als auch auf privaten Cloud Plattformen ausgeführt werden.  
+
+## Welches Problem es löst
+
+In der Vergangenheit wurden Rechenressourcen in Rechenzentren auf individuelle Weise bereitgestellt. 
+Anwendungen wurden eng an bestimmte Umgebungen gekoppelt und waren gewöhnlich auf eine manuelle Bereitstellung von Ressourcen wie virtuellen Maschinen angewiesen.
+Anwendungen, die nicht für den Betrieb in der Cloud konzipiert wurden, können sich die Vorteile einer Cloud Ausfallsicherheit und Skalierungsmöglichkeiten nicht gänzlich zu nutze machen. 
+Ein Beispiel dafür sind Anwendungen, die manuell gestartet werden müssen. Sie lassen sich nämlich nicht [horizontal skalieren](/horizontal-scaling/) und können bei einem Ausfall nicht automatisch neu gestartet werden. 
+
+## Wie es das Problem löst
+
+Cloud Native Anwendungen folgen gewissen Prinzipien, die sie für den Betrieb in einer Cloud optimieren und somit deren volles Potential ausschöpfen lässt.
+Zu dem Potential der Cloud gehören beispielsweise Skalierbarkeit, Ausfallsicherheit und Überwachung und diverse Automatisierungen. All das führt dazu, dass Cloud Native Anwendungen den modernen Anforderungen der heutigen Welt gerecht werden können. 
diff --git a/content/de/cloud-native-security.md b/content/de/cloud-native-security.md
new file mode 100644
index 0000000000..d6810c8135
--- /dev/null
+++ b/content/de/cloud-native-security.md
@@ -0,0 +1,32 @@
+---
+title: Cloud Native Security
+status: Completed
+category: Konzept
+---
+
+## Was es ist
+
+Cloud Native Security beschreibt den Ansatz, Konzepte aus dem Bereich Cyber Security in [Cloud Native Anwendungen](/cloud-native-apps/) zu integrieren. 
+Dabei ist vorgesehen, dass Sicherheitsbetrachtungen Teil des gesamten Softwareentwicklungs- und Lebenszyklus sind, von der Entwicklung bis zur Inbetriebnahme und Wartung.  
+Cloud Native Security versucht, die gleichen Standards wie herkömmliche Sicherheitsmodelle zu gewährleisten,
+ist dabei allerdings angepasst an die Besonderheiten von Cloud Native Umgebungen. 
+Eine hohe Frequenz von Änderungen des Codes und eine sehr volatile Infrastruktur sind Beispiele für die Eigenschaften von Cloud Native Umgebungen. 
+Cloud Native Security ist eng mit der Methodologie des [DevSecOps](/devsecops/) verbunden.
+
+## Welches Problem es löst
+
+Traditionelle Sicherheitsmodelle basieren auf einer Reihe von Annahmen, die nicht mehr länger gültig sind. 
+Cloud Native Anwendungen ändern sich häufig und verwenden eine große Anzahl von Open-Source-Tools und -Bibliotheken. 
+Sie werden oft in einer vom Cloud Provider kontrollierten Infrastruktur betrieben und unterliegen deshalb schnellen Infrastrukturänderungen, die sich der Kontrolle von Entwicklern entziehen.  
+Manuelle Code-Reviews, lange Qualitätssicherungszyklen, Host-basierte Schwachstellen-Scans und Sicherheitsüberprüfungen in letzter Minute skalieren somit schlecht für Cloud Native Anwendungen.
+
+## Wie es das Problem löst
+
+Cloud Native Security führt eine neue Arbeitsweise ein, die Anwendungen schützt, 
+indem sie von traditionellen Sicherheitsmodellen zu einem Modell übergeht, 
+bei dem die Sicherheit in jeden Schritt des Release-Zyklus einbezogen wird. 
+Manuelle Audits und Prüfungen werden weitgehend durch automatische Scans ersetzt. 
+Schnelle Code-Release-Pipelines werden mit Tools integriert, die den Code vor der Kompilierung auf Schwachstellen überprüfen. 
+Open-Source-Bibliotheken werden aus vertrauenswürdigen Quellen bezogen und auf Schwachstellen überprüft. 
+Anstatt den Wandel zu verlangsamen, unterstützt ein Cloud Native Sicherheitsmodell, 
+indem es anfällige Komponenten häufig aktualisiert oder sicherstellt, dass die Infrastruktur regelmäßig aktualisiert wird.
\ No newline at end of file
diff --git a/content/de/cloud-native-tech.md b/content/de/cloud-native-tech.md
new file mode 100644
index 0000000000..0b94c04d8e
--- /dev/null
+++ b/content/de/cloud-native-tech.md
@@ -0,0 +1,31 @@
+---
+title: Cloud Native Technologien
+status: Completed
+category: Konzept
+---
+
+## Was es ist
+
+Cloud Native Technologien, auch als Cloud Native Stack bezeichnet, sind Technologien, 
+die für die Entwicklung von Cloud Nativen Applikationen verwendet werden. 
+Diese Technologien ermöglichen es Organisationen, skalierbare Anwendungen in modernen und dynamischen Umgebungen wie Public-, Privat- und Hybrid-Clouds zu entwickeln und zu betreiben. 
+Sie sind darauf ausgelegt, die Vorteile des Cloud Computing voll auszuschöpfen. 
+Container, Service Meshes, Microservices und Immutable Infrastructure sind Beispiele für diesen Ansatz.
+
+## Welches Problem es löst
+
+Cloud Native Technologien sind in unterschiedliche Kategorien unterteilt, 
+die jeweils eine Vielzahl von Anwendungsfällen adressieren. 
+Ein Blick auf die [CNCF Cloud Native Landscape](https://landscape.cncf.io/) macht deutlich, wie viele unterschiedliche Bereiche dazu gehören. 
+Allgemein gesprochen adressieren Cloud Native Technologien allerdings immer den folgenden übergeordneten Anwendungsfall: 
+die Nachteile traditioneller IT-Betriebsmodelle zu kompensieren. 
+Zu diesen Nachteilen zählen unter anderem Schwierigkeiten bei der Erstellung von skalierbaren, fehlertoleranten, selbstheilenden Anwendungen, 
+sowie eine ineffiziente Ressourcennutzung.
+
+## Wie es das Problem löst
+
+Während jede Technologie auf einen ganz bestimmten Anwendungsfall abzielt, 
+ermöglichen Cloud Native Technologien insgesamt lose gekoppelte Systeme, 
+die belastbar sowie leichter zu verwalten und überwachen sind. 
+In Kombination mit robuster Automatisierung ermöglichen sie es Entwicklern, wichtige Änderungen häufig und vorhersehbar mit minimalem Aufwand vorzunehmen. 
+Cloud Native Technologien erleichtern es, moderne Softwaresysteme zu entwickeln, die den heutigen Anforderungen genügen.
diff --git a/content/de/contribute/_index.md b/content/de/contribute/_index.md
new file mode 100644
index 0000000000..a349f65d28
--- /dev/null
+++ b/content/de/contribute/_index.md
@@ -0,0 +1,110 @@
+---
+title: Wie Man etwas beitragen kann
+toc_hide: true
+menu:
+  main:
+    weight: 10
+    pre: <i class='fas fa-pen-square'></i>
+---
+
+Der Inhalt des Cloud Native Glossars ist [hier](https://github.com/cncf/glossary) gespeichert, wo sich eine Liste von [GitHub Issues](https://github.com/cncf/glossary/issues), [Pull Requests](https://github.com/cncf/glossary/pulls) und [Diskussionen](https://github.com/cncf/glossary/discussions) über das Glossar finden.
+
+Es gibt drei Möglichkeiten sich zu beteiligen:
+
+1) Neue Begriffe vorschlagen
+2) Existierende Begriffe aktualisieren 
+3) Bei der Übersetzung helfen
+
+## Werde Mitglied der Glossar-Community!
+Wer regelmäßig einen Beitrag leisten möchten, sollte an den monatlichen Treffen der Glossar-Arbeitsgruppe teilnehmen. Details zu den Treffen befinden sich im [CNCF Kalender] (https://www.cncf.io/calendar/). Ihr könnt euch auch mit den Betreuern und anderen Mitwirkenden in unserem #glossary Kanal über Slack austauschen - wir freuen uns auf euch! 
+
+## Neue Begriffe vorschlagen
+Ihr könnt neue Begriffe vorschlagen, an dem andere arbeiten sollen, oder selbst eine neue Definition erstellen. Der erste Schritt ist jedenfalls das Erstellen eines GitHub Issues für ein neues Anliegen (ein GitHub-Konto wird benötigt).
+
+Es folgt eine Schritt-für-Schritt-Anleitung für diejenigen, die mit GitHub noch nicht vertraut sind. **Wenn Du bereits ein GitHub-Profi** bist, verwende bitte unsere Vorlagen für die Erstellung eines neuen GitHub-Issue, achte darauf die richtigen Namenskonventionen und den [Style Guide] (https://glossary.cncf.io/style-guide/) einzuhalten, mach dich vertraut mit unseren Vorlagen und informiere uns über eingestellte Pull Requests über Slack (damit wir sie nicht übersehen). Vielen Dank! 
+
+### Neues GitHub Issue anlegen
+Gehe zu den [Github Issues](https://github.com/cncf/glossary/issues) des Glossar Repositories und klicke auf "New issue".
+
+![issues](/images/how-to/howto-01.png)
+
+Dort sind eine Vielzahl von Vorlagen zu sehen. Um einen neuen Begriff in deutscher Sprache vorzuschlagen, wähle "German Language Glossary Request".
+
+![templates](/images/how-to/howto-02.png)
+
+Füge den gewünschten Begriff ein, und klicke auf "Submit new issue". Falls du den Begriff lediglich vorschlagen wolltest, bist du jetzt bereits fertig! Falls du auch daran arbeiten möchtest, folge den nächsten Schritten. 
+
+![neues issue](/images/how-to/howto-03.png)
+
+Treten dem #glossary Kanal in dem CNCF Slack bei und teile  @Catherine Paganini, @jmo und @Seokho Son mit, dass du einen neuen Vorschlag eingereicht hast und daran arbeiten möchtest. Sie werden dir das GitHub-Issue zuweisen und allen anderen signalisieren, dass der Begriff bereits jemandem zugewiesen ist.
+
+Hier kannst du sehen, dass die ersten drei Begriffe verfügbar sind, während der letzte Begriff bereits jemandem zugewiesen wurde.
+
+![Begriff zuweisen](/images/how-to/howto-04.png)
+
+Beachte bitte, dass du jeweils nur an einen Begriff gleichzeitig arbeiten kannst. Falls du an mehreren Begriffen arbeiten möchtest, schließe bitte zuerst den einen ab, bevor du an dem anderen arbeitest. 
+
+### Begriff einreichen (Erstellen eines Pull Request)
+
+Stelle bitte vor dem Start sicher, den [Style Guide] (https://glossary.cncf.io/style-guide/) zu beachten - das wird weitere Interaktionen minimieren. Wie im Style Guide angegeben, empfehlen wir, mit einem Google- oder Word-Dokument zu beginnen. 
+
+Sobald der Begriff fertig ist, klicke bitte innerhalb der Registerkarte "Code" auf "content"  ...
+
+![Inhalt](/images/how-to/howto-05.png)
+
+... danach auf "de" ... 
+
+![Sprachen-Ordner](/images/how-to/howto-06.png)
+
+... wähle _TEMPLATE.md aus
+
+![Vorlage](/images/how-to/howto-07.png)
+
+kopiere den Inhalt ... 
+
+![Inhalt füllen](/images/how-to/howto-08.png)
+
+... wechsle wieder eine Ebene höher in den "de" Ordner. Jetzt einfach auf "add file" klicken und "create new file" auswählen.
+
+![Neue Datei anlegen](/images/how-to/howto-09.png)
+
+Füge den Namen des Begriffs in die URL ein (keine Großschreibung und kein Leerzeichen) mit dem Appendix ".md" (wenn die Vorschau nicht funktioniert, wurde das Appendix ".md" nicht korrekt hinzuzugefügt). Jetzt kann die ausgefüllte Vorlage eingefügt werden. Bitte beachte, dass GitHub Markdown verwendet um den Text zu formatieren (z. B. Hyperlink, fett, kursiv). Hier ein [Markdown Cheat Sheet](https://www.markdownguide.org/cheat-sheet/). Unter "Vorschau" kann man sehen wie der Text aussehen wird.
+
+![Finalisieren](/images/how-to/howto-10.png)
+
+Weiter unten kannst du unter "Commit new file" den Commit benennen und bestätigen sobald du dein Beitrag einreichen möchtest. Dafür wird der Commit zunächst auf einem eigenen Branch erstellt. Bestätige indem du auf "Commit new file" klickst ... 
+
+![Neue Datei commiten](/images/how-to/howto-11.png)
+
+...und erstelle einen Pull Request
+
+![Pull Request erstellen](/images/how-to/howto-12.png)
+
+Ab jetzt kannst du deinen erstellten Pull Requests hier verfolgen: 
+
+![Pull Requests](/images/how-to/howto-13.png)
+
+## Bestehenden Begriff aktualisieren
+
+Um einen bestehenden Begriff zu aktualisieren, kannst du entweder eine Änderung über ein neues GitHub Issue vorschlagen oder den Begriff direkt aktualisieren, indem du einen Pull Request einreichst.
+
+### Problem melden via GitHub Issue
+
+Falls du ein Problem mit einem Begriff melden, es aber nicht selber beheben möchtest oder kannst, klicke einfach auf "Problem melden".
+
+![Problem melden](/images/how-to/howto-14.png)
+
+Dadurch wird direkt ein GitHub Issue angelegt. Bitte beschreibe welche Änderung erforderlich ist und warum. Klicke auf "Submit new issue", und das war's. 
+
+![submit issue](/images/how-to/howto-15.png)
+
+### Änderungen direkt vornehmen
+
+Um einen Begriff direkt zu ändern, klicke auf "Diese Seite anpassen". 
+
+![Seite anpassen](/images/how-to/howto-16.png)
+
+Dadurch wird die GitHub-Seite des Begriffs geöffnet. Du kannst jetzt Anpassungen durchführen und einen Pull Request einreichen. Eine ausführliche Beschreibung findet sich weiter oben unter "Begriff einreichen" (du kannst direkt zu dem Abschnitt springen, in dem es um Markdown geht).
+
+## Hilf bei der Übersetzung des Glossars
+Falls du helfen möchtest, das Glossar in deine Muttersprache zu übersetzen, tritt dem Kanal #glossary-localizations auf dem CNCF Slack bei und lass es uns wissen. Du kannst entweder einem bestehenden Team beitreten oder ein neues Team gründen. Bitte nimm dazu auch an unseren monatlichen Treffen der Glossar-Arbeitsgruppe teil. Details zu den Treffen finden sich im [CNCF-Kalender] (https://www.cncf.io/calendar/). Wir freuen uns darauf, euch dort zu treffen!
diff --git a/content/de/style-guide/_index.md b/content/de/style-guide/_index.md
new file mode 100644
index 0000000000..5eb4b2c38e
--- /dev/null
+++ b/content/de/style-guide/_index.md
@@ -0,0 +1,127 @@
+---
+title: Style Guide
+toc_hide: true
+menu:
+  main:
+    weight: 10
+    pre: <i class='fas fa-ruler-horizontal'></i>
+---
+
+Dieser Style Guide hilft dir, die Zielgruppe, den Aufbau von Begriffsdefinitionen, den erforderlichen Detailgrad und das Einhalten eines einheitlichen Stils zu verstehen. 
+
+Das Cloud Native Glossar richtet sich nach dem [Standard Style Guide](https://github.com/cncf/foundation/blob/master/style-guide.md) des CNCF Repository. Zusätzlich gelten folgende Richtlinien:
+
+1. Verwende eine einfache, verständliche Sprache und vermeide bitte Fachjargon und Buzzwords
+2. [Vermeide Umgangssprache](https://de.wikipedia.org/wiki/Umgangssprache)
+3. [Benutze konkrete Aussagen](https://sprache.studiumineuropa.eu/s/4045/76932-Klar-und-deutlich-schreiben/4063659-7-Schreiben-Sie-konkret-nicht-abstrakt.htm)
+4. [Vermeide Kontraktionen](https://de.wikipedia.org/wiki/Kontraktion_(Linguistik))
+5. [Verwende passive Sätze nur sparsam](https://mein-deutschbuch.de/passiv-formen.html)
+6. [Achte darauf, Aussagen positiv zu formulieren ](https://examples.yourdictionary.com/positive-sentence-examples.html) 
+7. [Keine Ausrufezeichen außerhalb von Anführungszeichen](https://de.wikipedia.org/wiki/Ausrufezeichen)
+8. Nicht übertreiben
+9. Wiederholungen vermeiden
+10. Drücke dich klar aus
+
+## Audienz
+
+Das Glossar ist für ein technisches UND ein nichttechnisches Publikum geschrieben. Bitte stelle sicher, dass die Begriffe mit einfachen Worten erklärt werden, die keine technischen Kenntnisse voraussetzen. Mehr dazu weiter unten unter Definition.
+
+## Vorlage einer Definition
+
+Jeder Begriff wird in einer separaten Markdown-Datei abgelegt und folgt dieser Vorlage:
+
+```md
+---
+title: 
+status: 
+category: 
+---
+
+## Was es ist
+Eine kurze Zusammenfassung. 
+
+## Welches Problem es löst
+Kurze Erklärung darüber, welches Problem es löst. 
+
+## Wie es das Problem löst
+Erläuterung darüber, wie es das Problem löst. 
+```
+
+### Titel
+
+Das Label **title:** kommt an erster Stelle einer jeden Definitions-Seite. 
+
+```md
+---
+title: Vorlage für Definition
+```
+
+### Status
+
+Das Label **status** ist das zweite einer jeden Definitions-Seite, direkt nach dem **title**-Label. Der Status zeigt an, ob eine Begriffsdefinition überprüft und als vollständig markiert wurde, oder noch überarbeitet werden muss. 
+
+Gültige Werte sind die folgenden:
+
+- Completed (Abgeschlossen)
+- Feedback Appreciated (Feedback erwünscht)
+- Not Started (Nicht begonnen)
+
+Du kannst jederzeit ein GitHub-Issue für eine bereits bestehende Begriffsdefinition öffnen. Falls Feedback gewünscht wird, wird der Status auf *Feedback erwünscht* geändert.
+
+```md
+---
+title: Vorlage für Definition
+status: Feedback erwünscht
+```
+
+### Kategorie
+
+An letzer Stelle kommt das **category**-label. Gültige Werte sind die folgenden:
+
+- Technologie
+- Eigenschaft
+- Konzept
+
+```md
+---
+title: Vorlage für Definition
+status: Feedback erwünscht
+category: Konzept
+---
+```
+
+### Definition
+
+#### Drei Unterpunkte
+
+Definitionen der Kategorie **Technologie** und **Konzept** beinhalten folgende drei Unterpunkte:
+
+- **Was es ist**: Ein kurzer Überblick über den Begriff um den es geht. 
+- **Welches Problem es löst**: Fokus hierbei liegt auf dem Problem nicht auf der Lösung (die im nächsten Abschnitt behandelt wird). Bestenfalls wird der Begriff, der hier definiert überhaupt nicht erwähnt. Dieser Abschnitt konzentriert sich darauf, *warum* wir diese Sache brauchen. 
+- **Wie es das Problem löst**: Hier kommen wir auf den Begriff zu sprechen. Wie genau löst die Sache das im vorherigen Abschnitt beschriebene Problem?
+
+Anmerkung: Begriffsdefinitionen der Kategorie **Eigenschaft** benötigen keine Einteilung in die drei genannten Unterpunkte. Eine allgemeine Definition ist ausreichend. 
+
+#### Einfachheit
+
+Ziel des Glossars ist es, **komplexe Begriffe in einfachen Worten zu erklären** - das ist eine erstaunlich schwierige Aufgabe, die wahrscheinlich eine mehrfache Überarbeitung eines Begriffs benötigen. Die Zielgruppe sollte beim Verfassen einer Begriffsdefinition und deren Erstellung immer im Fokus sein. Vermeide bitte die Verwendung von Fachbegriffen und Buzzwords - Du wirst dich wahrscheinlich dabei ertappen, dass du auf diese zurückgreifen wirst.  
+
+Verwende gegebenenfalls **Beispiele aus der Praxis**, die den Lesern (vor allem Nicht-Technikern) helfen, besser zu verstehen, *wann* und *warum* der von dir erläuterte Begriff relevant ist. 
+
+Falls auf andere **bestehende Definition des Glossars** verwiesen wird, sollten diese (lediglich) bei ihrer ersten Erwähnung entsprechend verlinkt werden.  
+
+**Example**: take a look at the “What it is” section of the [service mesh definition](https://glossary.cncf.io/service_mesh/). It links back to the microservices, service, reliability, and observability definitions. Additionally, it uses a real-world example comparing network challenges in a microservices environment (something non-technical people can't relate to) to wifi problems (something anyone using a laptop can understand). Where possible, try to make that connection. //TODO as we don't have any article yet
+
+#### Beginne mit einem Google oder Word Dokument
+
+Wir empfehlen, mit einem Google- oder Word-Dokument zu beginnen, es ein paar Tage ruhen zu lassen und es dann erneut zu lesen. So wirst du sicher Sätze oder Ausdrücke finden, die einfacher und verständlicher formuliert werden könnten. Führe bitte außerdem eine Rechtschreibprüfung durch, bevor du einen PR einreichst.
+
+Um sicherzustellen, dass niemand anderes einen Pull Requests einreicht, während du an einem Begriff arbeitest, beanspruche den Begriff für dich (oder erstelle ein neues GitHub Issue) und lasse ihn dir zuweisen. Mehr dazu in der unter [wie man etwas beitragen kann](https://glossary.cncf.io/contribute/).
+
+Bevor du anfängst, lies bitte einige der veröffentlichten Glossarbegriffe, um ein Gefühl für den Detaillierungsgrad und den Schwierigkeitsgrad zu bekommen und um zu sehen, wann Beispiele angemessen sind.
+
+## Review Prozess: Was ist zu erwarten
+
+Bitte beachte, dass wir derzeit nur wenige Betreuer sind, die dies in ihrer Freizeit tun. Manchmal sind wir in der Lage, Begriffe schnell zu überprüfen, es kann aber auch einige Zeit dauern - wir danken euch für eure Geduld. Wenn du Fragen hast, wende dich bitte an uns im #glossary, #glossary-localizations oder #glossary-localization-german Slack-Kanal (weitere Infos findest du unter [wie man etwas beitragen kann](https://glossary.cncf.io/contribute/)).
+
+Unser Ziel ist es, dass das Glossar die bestmögliche Ressource ist. Wenn Du einen PR einreichst, werden wir dich möglicherweise um eine oder mehrere Überarbeitungen bitten. Sei bitte nicht frustriert - das ist bei vielen Pull Requests der Fall. Dieses Feedback-Schleifen unserer Zusammenarbeit werden sicherstellen, dass dein Beitrag zu einer wirklich nützlichen Definition wird, die von Lesern auf der ganzen Welt gelesen und herangezogen wird.
diff --git a/content/en/_index.md b/content/en/_index.md
index 9b4cd1feb6..78ed5121f3 100755
--- a/content/en/_index.md
+++ b/content/en/_index.md
@@ -1,5 +1,6 @@
 ---
 title: "Cloud Native Glossary"
+status: Completed
 ---
 
 # Cloud Native Glossary
@@ -7,7 +8,7 @@ title: "Cloud Native Glossary"
 The Cloud Native Glossary is a project led by the CNCF Business Value Subcommittee (BVS). 
 Its goal is to explain cloud native concepts in clear and simple language without requiring any previous technical knowledge.
 
-<p><img class="mt-5" src="/images/homepage/stage.jpg" alt="A woman and two men presenting technical info on a stage"></p>
+<p><img class="mt-3" src="/images/homepage/kubecon.jpg" alt="People watching a Kubecon presentation"></p>
 
 ## Contributing
 
diff --git a/content/en/abstraction.md b/content/en/abstraction.md
index 156b5fb005..436dd62747 100644
--- a/content/en/abstraction.md
+++ b/content/en/abstraction.md
@@ -2,7 +2,7 @@
 title: Abstraction
 status: Completed
 category: Property
-tags: ["architecture", "", ""]
+tags: ["fundamental", "", ""]
 ---
 
 In the context of computing, an abstraction is a representation that 
diff --git a/content/en/application-programming-interface.md b/content/en/application-programming-interface.md
index ffab216116..379792008b 100644
--- a/content/en/application-programming-interface.md
+++ b/content/en/application-programming-interface.md
@@ -1,8 +1,8 @@
 ---
-title: Application Programming Interface
+title: Application Programming Interface (API)
 status: Completed
 category: technology
-tags: ["architecture", "", ""]
+tags: ["architecture", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/auto-scaling.md b/content/en/auto-scaling.md
index 4c1f4aaf00..2b76962185 100644
--- a/content/en/auto-scaling.md
+++ b/content/en/auto-scaling.md
@@ -2,7 +2,7 @@
 title: Autoscaling
 status: Completed
 category: property
-tags: ["application", "infrastructure", "architecture"]
+tags: ["infrastructure", "", ""]
 ---
 
 Autoscaling is the ability of a system to [scale](/scalability/) automatically, typically, in terms of computing resources. 
diff --git a/content/en/blue-green-deployment.md b/content/en/blue-green-deployment.md
index b6433aa851..6aea7c7b57 100644
--- a/content/en/blue-green-deployment.md
+++ b/content/en/blue-green-deployment.md
@@ -2,7 +2,7 @@
 title: Blue Green Deployment
 status: Completed
 category: concept
-tags: ["application", "", ""]
+tags: ["methodology", "application", ""]
 ---
 
 ## What it is
diff --git a/content/en/canary-deployment.md b/content/en/canary-deployment.md
index 1f8e14deec..6006eb16d9 100644
--- a/content/en/canary-deployment.md
+++ b/content/en/canary-deployment.md
@@ -2,7 +2,7 @@
 title: Canary Deployment
 status: Completed
 category: concept
-tags: ["application", "", ""]
+tags: ["methodology", "application", ""]
 ---
 
 ## What it is
diff --git a/content/en/chaos-engineering.md b/content/en/chaos-engineering.md
index 891488924e..e01cf06d42 100644
--- a/content/en/chaos-engineering.md
+++ b/content/en/chaos-engineering.md
@@ -2,7 +2,7 @@
 title: Chaos Engineering
 status: Completed
 category: concept
-tags: ["security", "", ""]
+tags: ["methodology", "", ""]
 ---
 
 ## What it is
diff --git a/content/en/client-server-architecture.md b/content/en/client-server-architecture.md
index 00cea4c5d3..0a7bbfa1fb 100644
--- a/content/en/client-server-architecture.md
+++ b/content/en/client-server-architecture.md
@@ -2,7 +2,7 @@
 title: Client-Server Architecture
 status: Completed
 category: concept
-tags: ["architecture", "", ""]
+tags: ["architecture", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/cloud-computing.md b/content/en/cloud-computing.md
index 748ba4875a..0fd673f600 100644
--- a/content/en/cloud-computing.md
+++ b/content/en/cloud-computing.md
@@ -2,7 +2,7 @@
 title: Cloud Computing
 status: Completed
 category: concept
-tags: ["infrastructure", "", ""]
+tags: ["infrastructure", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/cloud-native-apps.md b/content/en/cloud-native-apps.md
index 2f3e2c6839..0c5a8c7777 100644
--- a/content/en/cloud-native-apps.md
+++ b/content/en/cloud-native-apps.md
@@ -2,7 +2,7 @@
 title: Cloud Native Apps
 status: Completed
 category: concept
-tags: ["application", "", ""]
+tags: ["application", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/cloud-native-tech.md b/content/en/cloud-native-tech.md
index a5198c5434..65aa54cfdb 100644
--- a/content/en/cloud-native-tech.md
+++ b/content/en/cloud-native-tech.md
@@ -2,7 +2,7 @@
 title: Cloud Native Technology
 status: Completed
 category: Concept
-tags: ["fundamentals", "", ""]
+tags: ["fundamental", "", ""]
 ---
 
 ## What it is
diff --git a/content/en/cluster.md b/content/en/cluster.md
index 83d81329c5..055260586b 100644
--- a/content/en/cluster.md
+++ b/content/en/cluster.md
@@ -2,7 +2,7 @@
 title: Cluster
 status: Completed
 category: Concept
-tags: ["infrastructure", "architecture", ""]
+tags: ["infrastructure", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/container-orchestration.md b/content/en/container-orchestration.md
new file mode 100644
index 0000000000..c1680f5f9a
--- /dev/null
+++ b/content/en/container-orchestration.md
@@ -0,0 +1,21 @@
+---
+title: Container Orchestration
+status: Completed
+category: Concept
+---
+
+## What it is
+[Container](/container/) orchestration refers to managing and automating the lifecycle of containerized applications in dynamic environments. 
+It's executed through a container orchestrator (in most cases, [Kubernetes](/kubernetes)), which enables deployments, (auto)scaling, auto-healing, and monitoring. 
+Orchestration is a metaphor:
+The orchestration tool conducts containers like a music conductor, ensuring every container (or musician) does what it should. 
+
+## Problem it addresses 
+Managing [microservices](/microservices), security, and network communication at scale — and [distributed systems](/distributed-systems) in general — is hard, if not impossible, to manage manually.
+Container orchestration allows users to automate all these management tasks. 
+
+## How it helps
+Container orchestration tools allow users to determine a system's state. 
+First, they declare how it should look like (e.g., x containers, y pods, etc.).
+The orchestration tool will then automatically monitor the infrastructure and correct it if its state deviates from the declared one (e.g., spin up a new container if one crashes). 
+This automation simplifies many of the engineering teams' otherwise highly manual and complex operational tasks, including provisioning, deployment, scaling (up and down), networking, load balancing, and other activities.
diff --git a/content/en/container.md b/content/en/container.md
index 2a36a76e50..29ec749c52 100644
--- a/content/en/container.md
+++ b/content/en/container.md
@@ -2,7 +2,7 @@
 title: Containers
 status: Completed
 category: technology
-tags: ["application", "", ""]
+tags: ["application", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/containers-as-a-service.md b/content/en/containers-as-a-service.md
index 62ba9ff39c..73c739070a 100644
--- a/content/en/containers-as-a-service.md
+++ b/content/en/containers-as-a-service.md
@@ -1,6 +1,6 @@
 ---
 title: Containers as a Service
-status: Completed
+status: Deprecated
 category: Technology
 tags: ["platform", "", ""]
 ---
diff --git a/content/en/continuous-delivery.md b/content/en/continuous-delivery.md
index 91b2e0a81f..67bf91e798 100644
--- a/content/en/continuous-delivery.md
+++ b/content/en/continuous-delivery.md
@@ -2,7 +2,7 @@
 title: Continuous Delivery (CD)
 status: Completed
 category: concept
-tags: ["application", "methodology", ""]
+tags: ["methodology", "application", ""]
 ---
 
 ## What it is
diff --git a/content/en/data-center.md b/content/en/data-center.md
index 9fff288db8..fe0c9a5937 100644
--- a/content/en/data-center.md
+++ b/content/en/data-center.md
@@ -2,7 +2,7 @@
 title: Data center
 status: Feedback Appreciated
 category: Technology
-tags: ["", "", ""]
+tags: ["infrastructure", "", ""]
 ---
 
 ## What it is
diff --git a/content/en/debugging.md b/content/en/debugging.md
index d9670072d4..1c8145d179 100644
--- a/content/en/debugging.md
+++ b/content/en/debugging.md
@@ -2,7 +2,7 @@
 title: Debugging
 status: Completed
 category: concept
-tags: ["application", "", ""]
+tags: ["application", "methodology", ""]
 ---
 
 ## What it is
diff --git a/content/en/devsecops.md b/content/en/devsecops.md
index 7789381cfc..66bf7de7c2 100644
--- a/content/en/devsecops.md
+++ b/content/en/devsecops.md
@@ -2,7 +2,7 @@
 title: DevSecOps 
 status: Completed
 category: concept
-tags: ["methodology", "", ""]
+tags: ["methodology", "security", ""]
 ---
 
 ## What it is
diff --git a/content/en/digital-certificate.md b/content/en/digital-certificate.md
index 49fed2e8c2..3b58b9905d 100644
--- a/content/en/digital-certificate.md
+++ b/content/en/digital-certificate.md
@@ -2,14 +2,14 @@
 title: Digital Certificate
 status: Feedback Appreciated
 category: technology
+tags: ["security", "", ""]
 ---
 
-
 ## What it is
 
 A (digital) certificate — also often referred to as a public key certificate, or SSL certificate — is a digital document used to help secure communications over the network. 
-Certificates allow us to know that the particular entity we're communicating with is who they say they are. They also allow us to ensure that our communications are private by encrypting the data we send and receive. 
-
+Certificates allow us to know that the particular entity we're communicating with is who they say they are.
+They also allow us to ensure that our communications are private by encrypting the data we send and receive.
 
 ## Problem it addresses
 
@@ -17,10 +17,8 @@ When devices communicate over a network there is no inherent guarantee that a pa
 Additionally, we can't guarantee that the traffic between any two devices won't be intercepted by a third party.
 Consequently, any communication can potentially be intercepted, compromising sensitive information like usernames and passwords. 
 
-
 ## How it helps
 
 Modern email clients that utilize certificates can notify you if a sender's identity is correct, as will web browsers (notice the little lock in front of the address bar of your web browser).
-On the other side, certificates can be used to encrypt communication between entities on the internet. They provide an encryption technique that makes it nearly impossible, for someone who intercepts the communication, to actually read the data. 
-
-## Related terms
+On the other side, certificates can be used to encrypt communication between entities on the internet.
+They provide an encryption technique that makes it nearly impossible, for someone who intercepts the communication, to actually read the data.
diff --git a/content/en/event-driven-architecture.md b/content/en/event-driven-architecture.md
index aa213e61be..1b0b56fd6c 100644
--- a/content/en/event-driven-architecture.md
+++ b/content/en/event-driven-architecture.md
@@ -2,6 +2,7 @@
 title: Event-Driven Architecture
 status: Completed
 category: concept
+tags: ["architecture", "", ""]
 ---
 
 ## What it is
diff --git a/content/en/event-streaming.md b/content/en/event-streaming.md
index 6415281b4f..529920e64e 100644
--- a/content/en/event-streaming.md
+++ b/content/en/event-streaming.md
@@ -2,6 +2,7 @@
 title: Event Streaming
 status: Completed
 category: concept
+tags: ["methodology", "networking", ""]
 ---
 
 ## What it is
@@ -11,7 +12,7 @@ Picture a service broadcasting everything it does to all other services.
 Each activity taken by a service is referred to as an event, hence event streaming.
 For example, NASDAQ gets updates on stock and commodities pricing every second.
 If you had an application that monitored a specific set of stocks, you would want to receive that information in near real-time.
-Yahoo! Finance provides an [API](https://glossary.cncf.io/application-programming-interface/) that pulls from NASDAQ and sends (or streams) the information (or events) from their application to any application that subscribes to it.
+Yahoo! Finance provides an [API](/application-programming-interface/) that pulls from NASDAQ and sends (or streams) the information (or events) from their application to any application that subscribes to it.
 The data being sent as well as the changes in that data (stock prices) are the events while the process of delivering them to an application is event streaming.
 
 ## Problem it addresses
diff --git a/content/en/firewall.md b/content/en/firewall.md
index 6273e89fcc..dcfbb8fa87 100644
--- a/content/en/firewall.md
+++ b/content/en/firewall.md
@@ -1,8 +1,8 @@
 ---
 title: Firewall
-status: Completed
+status: Deprecated
 category: Technology
-tags: ["security", "", ""]
+tags: ["Deprecated", "", ""]
 ---
 
 ## What it is
diff --git a/content/en/function-as-a-service.md b/content/en/function-as-a-service.md
index dd7f5ba8b6..ab96056c22 100644
--- a/content/en/function-as-a-service.md
+++ b/content/en/function-as-a-service.md
@@ -2,7 +2,7 @@
 title: Function as a Service (FaaS)
 status: Completed
 category: Technology
-tags: ["platform", "", ""]
+tags: ["infrastructure", "", ""]
 ---
 
 ## What it is
diff --git a/content/en/gitops.md b/content/en/gitops.md
index 2a2959d704..eed0abe284 100644
--- a/content/en/gitops.md
+++ b/content/en/gitops.md
@@ -2,7 +2,7 @@
 title: GitOps
 status: Feedback Appreciated
 category: Concept
-tags: ["", "", ""]
+tags: ["methodology", "", ""]
 ---
 
 ## What it is
diff --git a/content/en/hypervisor.md b/content/en/hypervisor.md
new file mode 100644
index 0000000000..cd16d6f70f
--- /dev/null
+++ b/content/en/hypervisor.md
@@ -0,0 +1,34 @@
+---
+title: Hypervisor
+status: Feedback Appreciated
+category: Technology
+tags: ["application", "", ""]
+---
+
+## What it is
+
+A hypervisor enables [virtualization](/virtualization/)
+by taking the advantage of [bare metal machine](/bare-metal-machine/) resources
+(CPU, Memory, Network, and Storage), dividing them into sub-parts, 
+and allocating resources accordingly to create  [virtual machines (VM)](/virtual-machine/)
+until the underlying host reaches its performance limits.
+
+## Problem it addresses
+
+Traditionally, a server could only run applications of a single operating system.
+The process of acquiring software takes time. It requires infrastructure with a specific environment
+and a team of engineers to manage and monitor them.
+Servers were underutilized, considering the computing power of a server it can run multiple operating systems and more applications.
+Running applications on bare metal wasn't enough to match the needs of fluctuating traffic.
+
+## How it helps
+
+In the context of [cloud computing](/cloud-computing/), the hypervisor becomes an effective tool.
+In contrast to the traditional method of creating a virtual machine, a hypervisor makes the process much simpler and faster. 
+Hardware resources are logically partitioned and assigned to the VMs keeping them isolated as distinct units,
+ensuring they function independently so that issues on one don't affect the others,
+and allowing VMs to install any necessary operating system.
+A hypervisor is an abstraction over the physical hardware, it takes care of those low-level complexities of managing the VMs and monitoring them,
+making VMs loosely bound to hardware, enabling organizations to migrate their applications to the remote servers/cloud 
+and autoscale their services.
+Over time, the use of this [multi-tenant](/multitenancy/) software has reduced computing costs.
diff --git a/content/en/idempotence.md b/content/en/idempotence.md
index 8272d0801c..1c2e4043e3 100644
--- a/content/en/idempotence.md
+++ b/content/en/idempotence.md
@@ -2,7 +2,7 @@
 title: Idempotence
 status: Completed
 category: Property
-tags: ["infrastructure", "architecture", ""]
+tags: ["property", "", ""]
 ---
 
 In maths or computer science, idempotence describes an operation that always leads to the same outcome, 
diff --git a/content/en/immutable-infrastructure.md b/content/en/immutable-infrastructure.md
index 247376b4c8..3a652a3644 100644
--- a/content/en/immutable-infrastructure.md
+++ b/content/en/immutable-infrastructure.md
@@ -2,7 +2,7 @@
 title: Immutable Infrastructure
 status: Completed
 category: property
-tags: ["infrastructure", "", ""]
+tags: ["infrastructure", "property", ""]
 ---
 
 Immutable Infrastructure refers to computer infrastructure 
diff --git a/content/en/infrastructure-as-code.md b/content/en/infrastructure-as-code.md
index 7ab5870ad7..a8c13bf8ab 100644
--- a/content/en/infrastructure-as-code.md
+++ b/content/en/infrastructure-as-code.md
@@ -2,7 +2,7 @@
 title: Infrastructure as Code (IaC)
 status: Completed
 category: concept
-tags: ["infrastructure", "", ""]
+tags: ["infrastructure", "methodology", ""]
 ---
 
 ## What it is
diff --git a/content/en/kubernetes.md b/content/en/kubernetes.md
index 778a9e0a7f..c33a36b12b 100644
--- a/content/en/kubernetes.md
+++ b/content/en/kubernetes.md
@@ -2,7 +2,7 @@
 title: Kubernetes
 status: Completed
 category: technology
-tags: ["infrastructure", "", ""]
+tags: ["infrastructure", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/load-balancer.md b/content/en/load-balancer.md
index 38e47fed86..ba2f3a3924 100644
--- a/content/en/load-balancer.md
+++ b/content/en/load-balancer.md
@@ -2,7 +2,7 @@
 title: Load Balancer
 status: Feedback Appreciated
 category: concept
-tags: ["", "", ""]
+tags: ["infrastructure", "networking", ""]
 ---
 
 ## What it is
diff --git a/content/en/loosely-coupled-architecture.md b/content/en/loosely-coupled-architecture.md
index f4397e43ef..8244d14332 100644
--- a/content/en/loosely-coupled-architecture.md
+++ b/content/en/loosely-coupled-architecture.md
@@ -2,7 +2,7 @@
 title: Loosely Coupled Architecture
 status: Completed
 category: Property
-tags: ["fundamentals", "", ""]
+tags: ["fundamental", "architecture", "property"]
 ---
 
 Loosely coupled architecture is an architectural style 
diff --git a/content/en/managed-services.md b/content/en/managed-services.md
index e897d55bc5..274fefad0f 100644
--- a/content/en/managed-services.md
+++ b/content/en/managed-services.md
@@ -1,6 +1,6 @@
 ---
 title: Managed services
-status: Completed
+status: Deprecated
 category: Technology
 tags: ["", "", ""]
 ---
diff --git a/content/en/microservices.md b/content/en/microservices.md
index 6a043577e9..43bf17a81a 100644
--- a/content/en/microservices.md
+++ b/content/en/microservices.md
@@ -2,7 +2,7 @@
 title: Microservices
 status: Completed
 category: concept
-tags: ["architecture", "", ""]
+tags: ["architecture", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/monolithic-apps.md b/content/en/monolithic-apps.md
index c02443bdb1..42ebb8fbd4 100644
--- a/content/en/monolithic-apps.md
+++ b/content/en/monolithic-apps.md
@@ -2,7 +2,7 @@
 title: Monolithic Apps
 status: Completed
 category: concept
-tags: ["architecture", "", ""]
+tags: ["architecture", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/multitenancy.md b/content/en/multitenancy.md
index 7554dfa40e..2780eccf6a 100644
--- a/content/en/multitenancy.md
+++ b/content/en/multitenancy.md
@@ -2,6 +2,7 @@
 title: Multitenancy
 status: Completed
 category: Property
+tags: ["architecture", "property", ""]
 ---
 
 ## What it is
diff --git a/content/en/mutual-transport-layer-security.md b/content/en/mutual-transport-layer-security.md
index ef8d5bc790..de54fa9c82 100644
--- a/content/en/mutual-transport-layer-security.md
+++ b/content/en/mutual-transport-layer-security.md
@@ -1,8 +1,8 @@
 ---
-title: mTLS (Mutual Transport Layer Security)
+title: Mutual Transport Layer Security (mTLS)
 status: Completed
 category: Concept
-tags: ["security", "", ""]
+tags: ["security", "networking", ""]
 ---
 
 ## What it is
diff --git a/content/en/nodes.md b/content/en/nodes.md
index 0fe2422c74..88a39b7c1a 100644
--- a/content/en/nodes.md
+++ b/content/en/nodes.md
@@ -2,7 +2,7 @@
 title: Nodes
 status: Completed
 category: Concept
-tags: ["architecture", "", ""]
+tags: ["infrastructure", "fundamental", ""]
 ---
 
 ## What it is
diff --git a/content/en/observability.md b/content/en/observability.md
index 26a5d5e769..5a2cd678bc 100644
--- a/content/en/observability.md
+++ b/content/en/observability.md
@@ -2,7 +2,7 @@
 title: Observability
 status: Completed
 category: concept
-tags: ["methodology", "application", "infrastructure"]
+tags: ["property", "", ""]
 ---
 
 ## What it is
diff --git a/content/en/platform-as-a-service.md b/content/en/platform-as-a-service.md
index e507a2b745..4c21c3dd1f 100644
--- a/content/en/platform-as-a-service.md
+++ b/content/en/platform-as-a-service.md
@@ -1,6 +1,6 @@
 ---
 title: Platform as a Service (PaaS)
-status: Completed
+status: Deprecated
 category: Technology
 tags: ["fundamentals", "platform", ""]
 ---
diff --git a/content/en/policy-as-code.md b/content/en/policy-as-code.md
index bef6fc6cac..c4df46fcd1 100644
--- a/content/en/policy-as-code.md
+++ b/content/en/policy-as-code.md
@@ -2,7 +2,8 @@
 title: Policy as Code (PaC)
 status: Feedback Appreciated
 category: concept
-tags: ["", "", ""]
+tags: ["methodology", "", ""]
+draft: true
 ---
 
 ## What it is
diff --git a/content/en/portability.md b/content/en/portability.md
index 1dd75864f9..0fe41ecaa4 100644
--- a/content/en/portability.md
+++ b/content/en/portability.md
@@ -2,7 +2,7 @@
 title: Portability
 status: Completed
 category: Property
-tags: ["fundamentals", "", ""]
+tags: ["fundamental", "property", ""]
 ---
 
 A software characteristic, portability is a form of reusability that helps to avoid "lock-in" to certain operating environments, 
diff --git a/content/en/reliability.md b/content/en/reliability.md
index 2a9c332c62..c1ab8a5bee 100644
--- a/content/en/reliability.md
+++ b/content/en/reliability.md
@@ -2,7 +2,7 @@
 title: Reliability
 status: Completed
 category: property
-tags: ["fundamentals", "", ""]
+tags: ["fundamental", "property", ""]
 ---
 
 From a cloud native perspective, reliability refers to how well a system responds to failures. 
diff --git a/content/en/scalability.md b/content/en/scalability.md
index 4129f50bf4..0c9a648e30 100644
--- a/content/en/scalability.md
+++ b/content/en/scalability.md
@@ -2,7 +2,7 @@
 title: Scalability
 status: Completed
 category: property
-tags: ["fundamentals", "", ""]
+tags: ["fundamental", "property", ""]
 ---
 
 Scalability refers to how well a system can grow. 
diff --git a/content/en/security-chaos-engineering.md b/content/en/security-chaos-engineering.md
index f958b06192..646f57bce6 100644
--- a/content/en/security-chaos-engineering.md
+++ b/content/en/security-chaos-engineering.md
@@ -2,7 +2,7 @@
 title: Security Chaos Engineering
 status: Completed
 category: concept
-tags: ["security", "", ""]
+tags: ["security", "methodology", ""]
 ---
 
 ## What it is
diff --git a/content/en/self-healing.md b/content/en/self-healing.md
index 781fc73245..98fef7f152 100644
--- a/content/en/self-healing.md
+++ b/content/en/self-healing.md
@@ -2,7 +2,7 @@
 title: Self Healing
 status: Completed
 category: property
-tags: ["infrastructure", "architecture", ""]
+tags: ["infrastructure", "property"]
 ---
 
 A self-healing system is capable of recovering from certain types of failure without any human intervention. 
diff --git a/content/en/serverless.md b/content/en/serverless.md
index 2b868af7cb..7ea7dfa7b1 100644
--- a/content/en/serverless.md
+++ b/content/en/serverless.md
@@ -2,7 +2,7 @@
 Title: Serverless
 Status: Completed
 Category: Technology
-tags: ["infrastructure", "", ""]
+tags: ["architecture", "", ""]
 ---
 
 ## What it is
diff --git a/content/en/service.md b/content/en/service.md
index 170f35b9d5..0aff4c4721 100644
--- a/content/en/service.md
+++ b/content/en/service.md
@@ -2,7 +2,7 @@
 title: Service
 status: Completed
 category: concept
-tags: ["architecture", "", ""]
+tags: ["application", "fundamental", ""]
 ---
 
 Please note that in IT, service has multiple meanings. 
diff --git a/content/en/software-as-a-service.md b/content/en/software-as-a-service.md
index bdbc9a1a48..b247e8170f 100644
--- a/content/en/software-as-a-service.md
+++ b/content/en/software-as-a-service.md
@@ -1,6 +1,6 @@
 ---
 Title: Software as a Service (SaaS)
-Status: Completed
+Status: Deprecated
 Category: Technology
 tags: ["fundamentals", "platform", ""]
 ---
diff --git a/content/en/stateful-apps.md b/content/en/stateful-apps.md
index 963c77465a..770308b536 100644
--- a/content/en/stateful-apps.md
+++ b/content/en/stateful-apps.md
@@ -2,7 +2,7 @@
 title: Stateful Apps
 status: Completed
 category: concept
-tags: ["fundamentals", "", ""]
+tags: ["fundamental", "application", ""]
 ---
 
 ## What it is
diff --git a/content/en/stateless-apps.md b/content/en/stateless-apps.md
index 31b685a2ef..fe9fa3fb79 100644
--- a/content/en/stateless-apps.md
+++ b/content/en/stateless-apps.md
@@ -2,7 +2,7 @@
 title: Stateless Apps
 status: Feedback Appreciated
 category: technology
-tags: ["fundamentals", "", ""]
+tags: ["fundamental", "application", ""]
 ---
 
 ## What it is
diff --git a/content/en/tightly-coupled-architectures.md b/content/en/tightly-coupled-architectures.md
index de4085efd8..d639b07a8a 100644
--- a/content/en/tightly-coupled-architectures.md
+++ b/content/en/tightly-coupled-architectures.md
@@ -2,7 +2,7 @@
 title: Tightly Coupled Architectures
 status: Completed
 category: Property
-tags: ["fundamentals", "", ""]
+tags: ["fundamental", "architecture", "property"]
 ---
 
 Tightly coupled architecture is an architectural style where a number of application components are interdependent 
diff --git a/content/en/transport-layer-security.md b/content/en/transport-layer-security.md
index ede6591cf4..2fd122fa62 100644
--- a/content/en/transport-layer-security.md
+++ b/content/en/transport-layer-security.md
@@ -1,8 +1,8 @@
 ---
-title: TLS
+title: Transport Layer Security (TLS)
 status: Completed
 category: Concept
-tags: ["security", "", ""]
+tags: ["security", "networking", ""]
 ---
 
 ## What it is
diff --git a/content/en/version-control.md b/content/en/version-control.md
index 0d02d2cb92..b43fae0e78 100644
--- a/content/en/version-control.md
+++ b/content/en/version-control.md
@@ -1,6 +1,6 @@
 ---
 title: Version Control
-status: Completed
+status: Deprecated
 category: Technology
 tags: ["methodology", "", ""]
 ---
diff --git a/content/en/virtual-machine.md b/content/en/virtual-machine.md
index ee893db8a5..4bf854f535 100644
--- a/content/en/virtual-machine.md
+++ b/content/en/virtual-machine.md
@@ -2,7 +2,7 @@
 title: Virtual Machine
 status: Completed
 category: Technology
-tags: ["fundamentals", "infrastructure", ""]
+tags: ["fundamental", "infrastructure", ""]
 ---
 
 ## What it is
diff --git a/content/en/virtualization.md b/content/en/virtualization.md
index 2b54eca30f..abf7ba25d8 100644
--- a/content/en/virtualization.md
+++ b/content/en/virtualization.md
@@ -2,7 +2,7 @@
 title: Virtualization
 status: completed
 category: technology
-tags: ["fundamentals", "infrastructure", ""]
+tags: ["fundamental", "infrastructure", "methodology"]
 ---
 
 ## What it is
diff --git a/content/es/.wordlist.txt b/content/es/.wordlist.txt
index 07a7b6b4b7..5d09f84ebe 100644
--- a/content/es/.wordlist.txt
+++ b/content/es/.wordlist.txt
@@ -1,122 +1,201 @@
 add
+Amazon
 an
 Aniszczyk
-Anyul
 API
 APIs
+App
+application
 Appreciated
-Ariel
+architecture
 Arnes
 autocura
+autoescalado
+autoescalamiento
+autorreparables
 AWS
 Azure
 backend
 bare
+based
+Benavides
 blob
 blue
 branch
+bug
+bugs
 Business
 BVS
 BY
 calendar
+Canary
+CAPEX
 Carol
 category
 Catherine
 CC
 CD
-Chaves
+Chaos
 Chris
 CI
+cifrada
 Cloud
 clúster
-cncf
-code
-com
+clústeres
+CNCF
+Code
 commit
 Committee
 community
 Completed
 concept
-conduct
+confiabilidad
+Container
+contenedores
+contenedorizadas
+contenedorizados
 contenerización
 content
 create
 creating
+CRI
 Daniel
+Datadog
 declarativamente
+Deployment
+deployments
+development
 DevOps
+DevSecOps
 DigitalOcean
 directly
 ej
-Emiliano
+Engine
+Engineering
 entregables
+escalarse
+escaneos
+evento
 existing
 extensibilidad
+externalizar
 Feedback
+Finance
 first
+fix
 Foster
 foundation
+Foundry
+framework
 frontend
+fundamentals
 Garcia
 gateway
 GCP
-github
+Git
+GitHub
+GitOps
 glossary
+Gmail
 good
 Google
 help
+Heroku
 hide
+hipervisor
+HTTP
 https
+IaaS
 IaC
 iamnoah
+indisponibilidad
+infrastructure
+Initiative
+inmutable
 interface
-io
 issue
 issues
 Jason
-Jhan
-Jhonnatan
 Jihoon
 jmo
 join
 Jones
+Kafka
 Katelin
 Kubernetes
 Language
 laptop
+Layer
 localizations
+loop
 main
 markdown
+Martinez
 md
 menu
+Mercurial
 mesh
+methodology
 microservicios
+Microsoft
 Mike
 mitigarse
+monitorean
+monitorear
+monitoreará
+monitoreo
 Morgan
+NASDAQ
 Native
 needed
+Netflix
+networking
 new
+Nicolas
 Not
+OCI
 of
 on
+on-premises
+Open
+PaaS
+PaC
 Paganini
+platform
+Política
+portable
 pr
+prem
+premises
+proactiva
 profesionistas
 properties
 propose
 PRs
 pull
+Quiceno
 Rael
 Ramer
+RDS
+relevantes
+reprogramados
 request
 requests
-Rivas
+resiliencia
+Rodolfo
+Runtime
 scripts
+Secure
+security
 Seokho
 service
 Slack
+sobreescriba
+Sockets
 Spanish
+SRE
+SSL
+stack
 Started
 status
 sub
@@ -124,6 +203,9 @@ Subcommittee
 submit
 submitting
 subrúbricas
+Subversion
+tags
+TCP
 technology
 TEMPLATE
 term
@@ -131,20 +213,25 @@ terms
 the
 title
 toc
+transmisión
 triaging
 true
+trunk
 update
 URL
 Value
-Vazquez
 Victor
+videos
+virtuales
 virtualización
+virtualizados
 vs
 weight
 wifi
 Word
 work
 www
+Yahoo
 YAML
 you
 your
diff --git a/content/es/_index.md b/content/es/_index.md
index b921aeda99..86b48c2ce6 100755
--- a/content/es/_index.md
+++ b/content/es/_index.md
@@ -1,28 +1,47 @@
 ---
 title: "Glosario Cloud Native"
+status: Completed
 ---
 
 # Glosario Cloud Native
 
-El Glosario Cloud Native es un proyecto liderado por la CNCF Business Value Subcommittee (BVS). Su meta es explicar los conceptos nativos para la nube en un lenguaje claro y simple sin recurrir a cualquier conocimiento técnico previo.
+El Glosario Cloud Native es un proyecto liderado por la CNCF Business Value Subcommittee (BVS).
+Su meta es explicar los conceptos nativos para la nube en un lenguaje claro y simple sin recurrir a cualquier conocimiento técnico previo.
 
 <p><img class="mt-5" src="/images/homepage/stage.jpg" alt="Una mujer y dos hombres presentando información técnica en el estrado"></p>
 
 ## Contribuyendo
 
-Todo mundo esta invitado a sugerir cambios, adiciones, y mejoras a el Glosario Cloud Native. Empleamos un proceso guiado por la comunidad y gobernado por la CNCF para desarrollar y mejorar este léxico compartido. Este Glosario provee una plataforma neutral de vendedores para organizar un vocabulario compartido alrededor de las tecnologías nativas para la nube. Las contribuciones son bienvenidas de todos los participantes que cumplan con el propósito y los estatutos del proyecto.
+Todo mundo esta invitado a sugerir cambios, adiciones, y mejoras a el Glosario Cloud Native.
+Empleamos un proceso guiado por la comunidad y gobernado por la CNCF para desarrollar y mejorar este léxico compartido.
+Este Glosario provee una plataforma neutral de vendedores para organizar un vocabulario compartido alrededor de las tecnologías nativas para la nube.
+Las contribuciones son bienvenidas de todos los participantes que cumplan con el propósito y los estatutos del proyecto.
 
-Cualquier persona que desee hacer una contribución puede enviar un GitHub issue o crear un pull request. Asegúrese de seguir la [Guía de estilo](/es/style-guide/), leer el documento de [Cómo contribuir](/es/contribute/) y unirse al canal de #glossary en el CNCF Slack. También hay un canal #glossary-localizations para aquellos que quieran ayudar a traducir el glosario a su idioma.
+Cualquier persona que desee hacer una contribución puede enviar un GitHub issue o crear un pull request.
+Asegúrese de seguir la [Guía de estilo](/es/style-guide/), leer el documento de [Cómo contribuir](/es/contribute/) y unirse al canal de [#glossary](https://cloud-native.slack.com/archives/C02TX20MQBB) en el CNCF Slack.
+También hay un canal [#glossary-localizations](https://cloud-native.slack.com/archives/C02N2RGFXDF) para aquellos que quieran ayudar a traducir el glosario a su idioma.
 
 ## Reconocimientos
 
-El Glosario Cloud Native fue iniciado por CNCF Marketing
-Committee (Business Value Subcommittee) e incluye
-contribuciones de [Catherine Paganini](https://www.linkedin.com/in/catherinepaganini/en/), [Chris Aniszczyk](https://www.linkedin.com/in/caniszczyk/),
-[Daniel Jones](https://www.linkedin.com/in/danieljoneseb/?originalSubdomain=uk), [Jason Morgan](https://www.linkedin.com/in/jasonmorgan2/), [Katelin Ramer](https://www.linkedin.com/in/katelinramer/), [Mike Foster](https://www.linkedin.com/in/mfosterche/?originalSubdomain=ca), [Seokho Son](https://www.linkedin.com/in/seokho-son/) y muchos contribuidores mas. Para una lista de contribuidores completa, consulte [esta página de GitHub](https://github.com/cncf/glossary/graphs/contributors).
-
-Esta versión del glosario Cloud Native en español incluye contribuciones realizadas por [Victor Morales](https://www.linkedin.com/in/electrocucaracha/), [Rael Garcia Arnes](https://www.linkedin.com/in/rael/), [Carol Valencia](https://www.linkedin.com/in/carolgv/), [Anyul Rivas](https://www.linkedin.com/in/anyulled/), [Emiliano Ariel Vazquez](https://www.linkedin.com/in/emiliano-ariel-vazquez-42ba5963/), [Jhan Carlos Silva](https://www.linkedin.com/in/shankyjs/), [Jhonnatan Gil Chaves](https://www.linkedin.com/in/jhonnatan-gil-chaves-57773919/)  y muchos otros colaboradores.
+El Glosario Cloud Native fue iniciado por CNCF Marketing Committee (Business Value Subcommittee) e incluye contribuciones de
+[Catherine Paganini](https://www.linkedin.com/in/catherinepaganini/en/),
+[Chris Aniszczyk](https://www.linkedin.com/in/caniszczyk/),
+[Daniel Jones](https://www.linkedin.com/in/danieljoneseb/?originalSubdomain=uk),
+[Jason Morgan](https://www.linkedin.com/in/jasonmorgan2/),
+[Katelin Ramer](https://www.linkedin.com/in/katelinramer/),
+[Mike Foster](https://www.linkedin.com/in/mfosterche/?originalSubdomain=ca),
+y muchos contribuidores mas.
+Para una lista de contribuidores completa, consulte [esta página de GitHub](https://github.com/cncf/glossary/graphs/contributors).
+
+Esta versión del glosario Cloud Native en español incluye contribuciones realizadas por
+[Victor Morales](https://www.linkedin.com/in/electrocucaracha/),
+[Rael Garcia Arnes](https://www.linkedin.com/in/rael/),
+[Carol Valencia](https://www.linkedin.com/in/carolgv/),
+[Nicolas Quiceno Benavides](https://www.linkedin.com/in/nquiceno/),
+[Rodolfo Martinez Vega](https://www.linkedin.com/in/rodomar/)
+y muchos otros colaboradores.
 
 ## Licencia
 
-Todas las contribuciones de código están bajo la licencia Apache 2.0. La documentación se distribuye bajo CC BY 4.0.
+Todas las contribuciones de código están bajo la licencia Apache 2.0.
+La documentación se distribuye bajo CC BY 4.0.
diff --git a/content/es/abstraction.md b/content/es/abstraction.md
index 12ad463591..ea55ffad78 100644
--- a/content/es/abstraction.md
+++ b/content/es/abstraction.md
@@ -2,8 +2,22 @@
 title: Abstracción
 status: Completed
 category: Propiedad
+tags: ["architecture", "", ""]
 ---
 
-En el contexto de la informática, una abstracción es una representación que oculta los detalles específicos a un consumidor de [servicios](/service/) (un consumidor que es un programa de computadora o un ser humano), haciendo un sistema más genérico y, por lo tanto, más fácil de entender. Un buen ejemplo es el sistema operativo (SO) de su computadora portátil. No necesita saber nada sobre el CPU, la memoria y cómo se manejan los programas, solo necesita operar el sistema operativo y el sistema operativo se ocupa de los detalles. Todos estos detalles se encuentran ocultos detrás de la "cortina" del sistema operativo o la abstracción.
+En el contexto de la informática, una abstracción es una representación que
+oculta los detalles específicos a un consumidor de [servicios](/service/)
+(un consumidor que es un programa de computadora o un ser humano),
+haciendo un sistema más genérico y, por lo tanto, más fácil de entender.
+Un buen ejemplo es el sistema operativo (SO) de su computadora portátil.
+Abstrae todos los detalles de cómo funciona su computadora.
+No necesita saber nada sobre el CPU, la memoria y cómo se manejan los programas,
+solo necesita operar el sistema operativo y el sistema operativo se ocupa de los detalles.
+Todos estos detalles se encuentran ocultos detrás de la "cortina" del sistema operativo o la abstracción.
 
-Los sistemas suelen tener varias capas de abstracción. Esto simplifica el desarrollo. Al programar, los desarrolladores construyen componentes compatibles con una capa de abstracción en particular y no tienen que preocuparse por todos los detalles de las capas anteriores, que pueden ser muy heterogéneas. Si funciona con la capa de abstracción, funciona con el sistema, sin importar lo que haya debajo.
+Los sistemas suelen tener varias capas de abstracción.
+Esto simplifica el desarrollo.
+Al programar, los desarrolladores construyen componentes compatibles con una capa de abstracción en particular y
+no tienen que preocuparse por todos los detalles de las capas anteriores, que pueden ser muy heterogéneas.
+Si funciona con la capa de abstracción, funciona con el sistema,
+sin importar lo que haya debajo.
diff --git a/content/es/agile-software-development.md b/content/es/agile-software-development.md
index d1be9ec129..8c1a9e18b8 100644
--- a/content/es/agile-software-development.md
+++ b/content/es/agile-software-development.md
@@ -2,16 +2,27 @@
 title: Desarrollo ágil de software
 status: Completed
 category: Concepto
+tags: ["methodology", "", ""]
 ---
 
 ## ¿Qué es?
 
-Un conjunto de prácticas que enfatizan el ciclo de desarrollo iterativo y equipos auto-organizados. En contraste con proyectos tradicionales en cascada donde el valor se genera solo al final del proyecto, el desarrollo ágil de software se enfoca en una entrega incremental y continua de valor y una mejora evolutiva del proceso en sí mismo.
+Un conjunto de prácticas que enfatizan el ciclo de desarrollo iterativo y equipos auto-organizados.
+En contraste con proyectos tradicionales en cascada donde el valor se genera solo al final del proyecto,
+el desarrollo ágil de software se enfoca en una entrega incremental y continua de valor y
+una mejora evolutiva del proceso en sí mismo.
 
 ## Problema que aborda
 
-Definir, comunicar y entender los requerimientos para todos las partes interesadas en un proyecto de software es muy difícil, cuando no imposible. Sin embargo, los clientes quieren que sus proyectos de software sean entregados a tiempo, con buena calidad, dentro del presupuesto y del alcance. Con su naturaleza cíclica, el desarrollo ágil de software habilita la adaptación continua de los requerimientos y la adaptación más rápida a otras circunstancias al contrario de estrategias tradicionales en cascada.
+Definir, comunicar y entender los requerimientos para todos las partes interesadas en un proyecto de software es muy difícil, cuando no imposible.
+Sin embargo, los clientes quieren que sus proyectos de software sean entregados a tiempo, con buena calidad, dentro del presupuesto y del alcance.
+Con su naturaleza cíclica, el desarrollo ágil de software habilita la adaptación continua de los requerimientos y
+la adaptación más rápida a otras circunstancias al contrario de estrategias tradicionales en cascada.
 
 ## ¿Cómo ayuda?
 
-El desarrollo ágil de software contiene todas las fases de las estrategias tradicionales (en cascada), como ingeniería de requerimientos, planificación, implementación, revisión, pruebas y entrega. La diferencia más grande es que toda la duración del proyecto se divide en iteraciones, cada una de las cuales contiene estas fases. Luego de cada iteración, se puede revisar con el cliente el valor generado y se pueden ajustar los requerimientos hacia el objetivo final. Adicionalmente, el equipo de desarrollo hace una retrospectiva de qué acciones tomar con la finalidad de mejorar el proceso en sí mismo.
+El desarrollo ágil de software contiene todas las fases de las estrategias tradicionales (en cascada),
+como ingeniería de requerimientos, planificación, implementación, revisión, pruebas y entrega.
+La diferencia más grande es que toda la duración del proyecto se divide en iteraciones, cada una de las cuales contiene estas fases.
+Luego de cada iteración, se puede revisar con el cliente el valor generado y se pueden ajustar los requerimientos hacia el objetivo final.
+Adicionalmente, el equipo de desarrollo hace una retrospectiva de qué acciones tomar con la finalidad de mejorar el proceso en sí mismo.
diff --git a/content/es/api-gateway.md b/content/es/api-gateway.md
index 9c75fcc309..44ed31f42a 100644
--- a/content/es/api-gateway.md
+++ b/content/es/api-gateway.md
@@ -2,16 +2,31 @@
 title: API Gateway
 status: Completed
 category: Tecnología
+tags: ["networking", "", ""]
 ---
 
-## ¿Qué es esto?
+## ¿Qué es?
 
-Un API Gateway es una herramienta que concentra diferentes aplicaciones [APIs](/application-programming-interface/), centralizando a todas en un solo lugar. Esto permite a las organizaciones mover funciones clave, como puede ser la autenticación y la autorización o limitando el número de peticiones entre aplicaciones a una ubicación de administración centralizada. Un API Gateway funciona como una interface común para los que la consumen (usualmente aplicaciones externas).
+Un [API](/es/application-programming-interface/) gateway es una herramienta que
+concentra aplicaciones APIs únicas, centralizando a todas en un solo lugar.
+Esto permite a las organizaciones mover funciones clave,
+como puede ser la autenticación y la autorización o limitando el número de peticiones entre aplicaciones
+a una ubicación de administración centralizada.
+Un API Gateway funciona como una interface común para los que la consumen (usualmente aplicaciones externas).
 
-## El problema que aborda
+## Problema que aborda
 
-Si está haciendo APIs con disponibilidad para consumidores externos, es deseable tener un único punto de entrada para administrar y controlar todo el acceso. Adicionalmente, si necesita aplicar funcionalidad en estas interacciones, un API Gateway le permitirá aplicarla de manera uniforme a todo el tráfico, sin requerir cambios en el código de la aplicación.
+Si está haciendo APIs con disponibilidad para consumidores externos,
+es deseable tener un único punto de entrada para administrar y controlar todo el acceso.
+Adicionalmente, si necesita aplicar funcionalidad en estas interacciones,
+un API Gateway le permitirá aplicarla de manera uniforme a todo el tráfico, sin requerir cambios en el código de la aplicación.
 
-## ¿Cómo Ayuda?
+## ¿Cómo ayuda?
 
-Proporcionando un único punto de acceso para varias APIs en una aplicación, los API Gateway simplifican la organización para aplicar decisiones de negocio transversales o lógicas de seguridad en una ubicación central. Adicionalmente, permiten a los consumidores de aplicaciones ir en una única dirección para todas sus necesidades. Un API Gateway puede simplificar preocupaciones operativas, como son la seguridad y la [observabilidad](/es/observability/) proporcionando un único punto de acceso para las peticiones a todos los servicios web en el sistema. Como todas las peticiones fluyen por el gateway, esto presenta un lugar único para agregar funcionalidades como la recolección de métricas, límites de tráfico y la autorización.
+Proporcionando un único punto de acceso para varias APIs en una aplicación,
+los API Gateway simplifican la organización para aplicar decisiones de negocio transversales o lógicas de seguridad en una ubicación central.
+Adicionalmente, permiten a los consumidores de aplicaciones ir en una única dirección para todas sus necesidades.
+Un API Gateway puede simplificar preocupaciones operativas, como son la seguridad y la [observabilidad](/es/observability/)
+proporcionando un único punto de acceso para las peticiones a todos los servicios web en el sistema.
+Como todas las peticiones fluyen por el gateway, esto presenta un lugar único para
+agregar funcionalidades como la recolección de métricas, límites de tráfico y la autorización.
diff --git a/content/es/application-programming-interface.md b/content/es/application-programming-interface.md
new file mode 100644
index 0000000000..0ad9bda1f4
--- /dev/null
+++ b/content/es/application-programming-interface.md
@@ -0,0 +1,26 @@
+---
+title: Interfaz de programación de aplicaciones  (API)
+status: Completed
+category: Tecnología
+tags: ["architecture", "", ""]
+---
+
+## ¿Qué es?
+
+Una API es una manera en la que los programas de computadoras interactúan entre sí.
+Tal como los humanos interactúan con un sitio web a través de la página web, una API permite a los programas de las computadoras interactuar entre sí.
+A diferencia de las interacciones humanas, las APIs tienen limitaciones en lo que se le puede preguntar o no a las mismas.
+La limitación en la interacción ayuda a crear comunicaciones estables y funcionales entre los diferentes programas.
+
+## Problema que aborda
+
+A medida que las aplicaciones se vuelven más complejas, cualquier tipo de cambio en el mismo puede afectar drásticamente otras funcionalidades.
+Las aplicaciones deben adoptar un enfoque modular para sus funcionalidades así pueden crecer y mantener la estabilidad simultáneamente.
+Sin las APIs, falta un marco para la interacción entre las aplicaciones.
+Sin un marco compartido, la [escalabilidad](/scalability/) y la integración es un desafío para las aplicaciones.
+
+## ¿Cómo ayuda?
+
+Las APIs permiten a los programas o aplicaciones interactuar y compartir información en una manera definida y entendible.
+Estas están construidas en bloques para aplicaciones modernas y proveen a los desarrolladores una manera de integrar aplicaciones.
+Siempre que escuche acerca de [microservicios](/microservices/) trabajando en conjunto, se puede inferir que están interactuando a través de una API.
diff --git a/content/es/auto-scaling.md b/content/es/auto-scaling.md
new file mode 100644
index 0000000000..b5b23f8585
--- /dev/null
+++ b/content/es/auto-scaling.md
@@ -0,0 +1,28 @@
+---
+title: Autoescalado
+status: Completed
+category: Propiedad
+tags: ["application", "infrastructure", "architecture"]
+---
+
+El autoescalado es la habilidad de un sistema para [escalar](/scalability) automáticamente, en términos de recursos computacionales.
+Con un sistema de autoescalado, los recursos son agregados automáticamente cuando se necesitan y pueden escalar para cumplir con la demanda fluctuante de los usuarios.
+El proceso de autoescalado varía y es configurable para escalar basado en diferentes métricas, como son la memoria o el uso de CPU.
+Los servicios gestionados en la nube son los que están asociados típicamente con esta funcionalidad de autoescalado
+pero también hay opciones e implementaciones disponibles para la mayoría de los servicios existentes.
+
+Anteriormente, la infraestructura y las aplicaciones eran diseñadas para considerar los picos de uso del sistema.
+Esta arquitectura implicaba que había más recursos que eran desaprovechados o con cambios rígidos frente a la demanda de los usuarios.
+La rigidez en este caso, incrementa el coste y puede suponer una pérdida de negocios debido a problemas de capacidad.
+
+Aprovechando la nube, la [virtualización](/virtualization) y la [contenerización](/es/containerization/) de aplicaciones y sus dependencias,
+las organizaciones pueden construir aplicaciones que escalan de manera acorde a la demanda de los usuarios.
+Se pueden monitorear la demanda de las aplicaciones y de manera automática escalar las mismas, proporcionando una experiencia al usuario final óptima.
+Tomemos el ejemplo del aumento de la audiencia de Netflix todos los viernes por la noche.
+El autoescalado significa agregar más recursos dinámicamente: por ejemplo,
+incrementando el número de servidores que permitirán una mayor transmisión de los videos y reduciendo los servidores una vez que el consumo se ha normalizado.
+
+## Términos relacionados
+
+* [Escalado Horizontal](/horizontal-scaling/)
+* [Escalado Vertical](/vertical-scaling/)
diff --git a/content/es/bare-metal-machine.md b/content/es/bare-metal-machine.md
index b32363ae0c..ccdd46048e 100644
--- a/content/es/bare-metal-machine.md
+++ b/content/es/bare-metal-machine.md
@@ -2,18 +2,33 @@
 title: Máquina Bare Metal
 status: Completed
 category: Tecnología
+tags: ["infrastructure", "", ""]
 ---
 
 ## ¿Qué es?
 
-Bare metal se refiere a una computadora física, más específicamente un servidor, que tiene un solo sistema operativo. La distinción es importante en la informática moderna porque muchos, si no es que la mayoría, de los servidores son [máquinas virtuales](/virtual-machine/). Un servidor físico suele ser una computadora bastante grande con un potente hardware incorporado. La instalación de un sistema operativo y la ejecución de aplicaciones directamente en ese hardware físico, sin [virtualización](/virtualization/), se conoce como ejecución "bare metal".
+Bare metal se refiere a una computadora física, más específicamente un servidor, que tiene un solo sistema operativo.
+La distinción es importante en la informática moderna porque muchos, si no es que la mayoría, de los servidores son [máquinas virtuales](/virtual-machine/).
+Un servidor físico suele ser una computadora bastante grande con un potente hardware incorporado.
+La instalación de un sistema operativo y la ejecución de aplicaciones directamente en ese hardware físico,
+sin [virtualización](/virtualization/), se conoce como ejecución "bare metal".
 
 ## Problema que aborda
 
-Emparejar un sistema operativo con una computadora física es el patrón original de la informática. Todos los recursos de la computadora física están disponibles directamente para el sistema operativo y sin la presencia de una capa de virtualización, no hay un retraso artificial en la traducción de las instrucciones del sistema operativo al hardware.
+Emparejar un sistema operativo con una computadora física es el patrón original de la informática.
+Todos los recursos de la computadora física están disponibles directamente para el sistema operativo y sin la presencia de una capa de virtualización,
+no hay un retraso artificial en la traducción de las instrucciones del sistema operativo al hardware.
 
 ## ¿Cómo ayuda?
 
-Al dedicar todos los recursos informáticos de una computadora a un solo sistema operativo, potencialmente se proporciona el mejor rendimiento posible al sistema operativo. Si necesita ejecutar una carga de trabajo que debe tener un acceso extremadamente rápido a los recursos de hardware, bare metal puede ser la solución adecuada.
+Al dedicar todos los recursos informáticos de una computadora a un solo sistema operativo,
+potencialmente se proporciona el mejor rendimiento posible al sistema operativo.
+Si necesita ejecutar una carga de trabajo que debe tener un acceso extremadamente rápido a los recursos de hardware,
+bare metal puede ser la solución adecuada.
 
-En el contexto de las [aplicaciones nativas de la nube](/cloud-native-apps/), generalmente pensamos en el rendimiento en términos de [escalabilidad](/scalability/) para una gran cantidad de eventos simultáneos, que pueden mitigarse mediante el [escalado horizontal](/horizontal-scaling/) (agregando más máquinas a su grupo de recursos). Sin embargo, algunas cargas de trabajo pueden requerir [escalado vertical](/vertical-scaling/) (agregar más potencia a una máquina física existente) y/o una respuesta extremadamente rápida de hardware físico, en cuyo caso se adapta mejor el bare metal. Bare metal también le permite ajustar el hardware físico y posiblemente incluso los controladores de hardware para ayudarlo a realizar su tarea.
+En el contexto de las [aplicaciones nativas para la nube](/es/cloud-native-apps/),
+generalmente pensamos en el rendimiento en términos de [escalabilidad](/scalability/) para una gran cantidad de eventos simultáneos,
+que pueden mitigarse mediante el [escalado horizontal](/horizontal-scaling/) (agregando más máquinas a su grupo de recursos).
+Sin embargo, algunas cargas de trabajo pueden requerir [escalado vertical](/vertical-scaling/) (agregar más potencia a una máquina física existente)
+y/o una respuesta extremadamente rápida de hardware físico, en cuyo caso se adapta mejor el bare metal.
+Bare metal también le permite ajustar el hardware físico y posiblemente incluso los controladores de hardware para ayudarlo a realizar su tarea.
diff --git a/content/es/blue-green-deployment.md b/content/es/blue-green-deployment.md
index 7881962855..37bf60408b 100644
--- a/content/es/blue-green-deployment.md
+++ b/content/es/blue-green-deployment.md
@@ -2,16 +2,30 @@
 title: Despliegue Blue Green
 status: Completed
 category: Concepto
+tags: ["application", "", ""]
 ---
 
 ## ¿Qué es?
 
-El despliegue Blue green es una estrategia para actualizar los sistemas informáticos en ejecución con un tiempo de inactividad mínimo. El operador mantiene dos entornos, llamados "blue" y "green". Uno sirve el tráfico de producción (la versión que todos los usuarios usan actualmente), mientras que el otro está actualizado. Una vez que las pruebas han concluido en el entorno inactivo (green), el tráfico de producción se cambia (a menudo mediante el uso de un balanceador de cargas). Ten en cuenta que el despliegue blue-green usualmente significa cambiar los entornos por completo, comprendiendo muchos servicios, todos a la vez. Confusamente, algunas veces el término se utiliza para referirse a servicios dentro de un sistema. Para evitar esta ambigüedad, se prefiere el término "despliegue con tiempo de inactividad cero" cuando se refiere a componentes individuales.
+El despliegue Blue green es una estrategia para actualizar los sistemas informáticos en ejecución con un tiempo de inactividad mínimo.
+El operador mantiene dos entornos, llamados "blue" y "green".
+Uno sirve el tráfico de producción (la versión que todos los usuarios usan actualmente), mientras que el otro está actualizado.
+Una vez que las pruebas han concluido en el entorno inactivo (green),
+el tráfico de producción se cambia (a menudo mediante el uso de un [balanceador de cargas](/es/load-balancer/).
+Ten en cuenta que el despliegue blue-green usualmente significa cambiar los entornos por completo, comprendiendo muchos [servicios](/service/), todos a la vez.
+Confusamente, algunas veces el término se utiliza para referirse a servicios dentro de un sistema.
+Para evitar esta ambigüedad, se prefiere el término "despliegue con tiempo de inactividad cero" cuando se refiere a componentes individuales.
 
 ## Problema que aborda
 
-Los despliegues blue-green permiten un tiempo de inactividad mínimo al actualizar el software que se debe cambiar en "paso a paso" debido a la falta de compatibilidad con versiones anteriores. Por ejemplo, el despliegue blue-green sería apropiado para una tienda en línea que consiste de un sitio web y una base de datos que necesita ser actualizada, pero la nueva versión de la base de datos no funciona con la versión vieja del sitio web, y viceversa. En esta instancia, ambos necesitan ser cambiados al mismo tiempo. Si esto se realiza en un sistema en producción, los clientes notarían un tiempo de inactividad.
+Los despliegues blue-green permiten un tiempo de inactividad mínimo al actualizar el software que se debe cambiar en "paso a paso" debido a la falta de compatibilidad con versiones anteriores.
+Por ejemplo, el despliegue blue-green sería apropiado para una tienda en línea
+que consiste de un sitio web y una base de datos que necesita ser actualizada,
+pero la nueva versión de la base de datos no funciona con la versión vieja del sitio web, y viceversa.
+En esta instancia, ambos necesitan ser cambiados al mismo tiempo.
+Si esto se realiza en un sistema en producción, los clientes notarían un tiempo de inactividad.
 
 ## ¿Cómo ayuda?
 
-El despliegue blue-green es una estrategia apropiada para el software que no está en la nube que se necesita actualizar con tiempo de inactividad mínimo. Sin embargo, su uso es una señal de que el software heredado necesita ser rediseñado para que los componentes se puedan actualizar individualmente.
+El despliegue blue-green es una estrategia apropiada para el software que no está en la nube que se necesita actualizar con tiempo de inactividad mínimo.
+Sin embargo, su uso es una señal de que el software heredado necesita ser rediseñado para que los componentes se puedan actualizar individualmente.
diff --git a/content/es/canary-deployment.md b/content/es/canary-deployment.md
new file mode 100644
index 0000000000..d5b8a80465
--- /dev/null
+++ b/content/es/canary-deployment.md
@@ -0,0 +1,33 @@
+---
+title: Canary Deployment
+status: Completed
+category: Concepto
+tags: ["application", "", ""]
+---
+
+## ¿Qué es?
+
+Canary deployment es una estrategia de despliegue que comienza con dos entornos:
+uno con tráfico y otro que contiene el código actualizado sin tráfico.
+El tráfico se traslada gradualmente de la versión original de la aplicación a la versión actualizada.
+Puede comenzar moviendo el 1 % del tráfico, luego el 10 %, el 25 %, y así sucesivamente,
+hasta que todo el tráfico se ejecute en la versión actualizada.
+Las organizaciones pueden probar la nueva versión del software en producción, obtener comentarios,
+diagnosticar errores y volver rápidamente a la versión estable si es necesario.
+
+El término "canario" (canary en inglés) se refiere a la práctica de "canario en una mina de carbón"
+en la que se llevaban pájaros canarios a las minas de carbón para mantener mineros seguros.
+Si hubiera gases nocivos inodoros, el ave moriría y los mineros sabían que tenían que evacuar con rapidez.
+De manera similar, si algo sale mal con el código actualizado, el tráfico se "evacua" de regreso a la versión original.
+
+## Problema que aborda
+
+No importa cuán minucioso sea el control de calidad de una nueva versión, siempre se descubren algunos errores en producción.
+Cambiar el 100 % del tráfico de una versión de una aplicación a otra puede generar fallas más impactantes.
+
+## ¿Cómo ayuda?
+
+Canary deployments permiten a las organizaciones ver cómo se comporta el nuevo software en escenarios del mundo real
+antes de mover una cantidad significativa de tráfico a la nueva versión.
+Esta estrategia permite a las organizaciones minimizar el tiempo de inactividad y revertir rápidamente en caso de problemas con la nueva implementación.
+También permite pruebas de aplicaciones de producción más profundas sin un impacto significativo en la experiencia general del usuario.
diff --git a/content/es/chaos_engineering.md b/content/es/chaos_engineering.md
new file mode 100644
index 0000000000..671dfe82b7
--- /dev/null
+++ b/content/es/chaos_engineering.md
@@ -0,0 +1,17 @@
+---
+title: Ingeniería del Caos 
+status: Completed
+category: Concepto
+---
+
+## ¿Qué es?
+
+Ingeniería del Caos o CE (Chaos Engineering) es la disciplina de experimentación sobre un [Sistema Distribuido](/distributed_systems/) en producción para construir confianza en la capacidad del sistema para soportar condiciones inesperadas y turbulentas.
+
+## Problema que aborda
+
+Las prácticas de [SRE](/site_reliability_engineering/) y [DevOps](/es/devops/) se centran en el incremento de la resiliencia del producto y de la [confiabilidad](/reliability/). La capacidad del sistema para tolerar fallos al mismo tiempo que aseguran una calidad de servicio adecuado suele ser un típico requerimiento de desarrollo de software. Existen muchos aspectos involucrados al momento de la indisponibilidad de una aplicación, como la infraestructura, la plataforma o otras partes del ecosistema de las aplicaciones basadas en ([microservicios](/microservices/)). La alta frecuencia de despliegues de funcionalidades hacia el ambiente productivo aumenta la posibilidad de un incidente crítico o estar fuera de línea - generando consecuencias considerables para el negocio.
+
+## ¿Cómo ayuda?
+
+La Ingeniería del Caos es una técnica para cumplir los requerimientos de resiliencia. Esta disciplina ayuda a obtener una infraestructura, plataforma y aplicación resistente ante fallos. Los ingenieros utilizan los experimentos de caos de forma proactiva inyectando fallas aleatorias para verificar que la infraestructura, plataforma y aplicación puedan auto recuperarse y que la falla no sea de notable impacto para los usuarios finales. Los experimentos de caos buscan descubrir puntos ciegos (por ejemplo, monitoreo o técnicas de autoescalamiento) y mejorar la comunicación entre los equipos durante incidentes críticos. Este acercamiento ayuda a incrementar la resiliencia y la confianza de los equipos en sistemas complejos, particularmente en producción.
diff --git a/content/es/client-server-architecture.md b/content/es/client-server-architecture.md
new file mode 100644
index 0000000000..a49f46e143
--- /dev/null
+++ b/content/es/client-server-architecture.md
@@ -0,0 +1,36 @@
+---
+title: Arquitectura Cliente-Servidor
+status: Completed
+category: Concepto
+tags: ["architecture", "", ""]
+---
+
+## ¿Qué es?
+
+En una arquitectura cliente-servidor, la lógica (o código) que constituye una aplicación se divide en dos o más componentes:
+un cliente que solicita trabajo por hacer
+(por ejemplo, la aplicación web Gmail que se ejecuta en su navegador web),
+y otro o más servidores que satisfagan esa solicitud
+(por ejemplo, el servicio de "enviar correo electrónico" que se ejecuta en las computadoras de Google en la nube).
+En este ejemplo, los correos electrónicos salientes que escribe son enviados por el cliente (aplicación web que se ejecuta en su navegador web)
+a un servidor (las computadoras de Gmail, que reenvían sus correos electrónicos salientes a sus destinatarios).
+
+Esto contrasta con las aplicaciones autónomas (como las aplicaciones de escritorio) que hacen todo el trabajo en un solo lugar.
+Por ejemplo, un programa de procesamiento de textos como Microsoft Word puede instalarse y ejecutarse completamente en su computadora.
+
+## Problema que aborda
+
+Una arquitectura cliente-servidor resuelve un gran desafío que plantean las aplicaciones autónomas: actualizaciones periódicas.
+En una aplicación autónoma, para cada actualización, los usuarios tendrían que descargar e instalar la última versión.
+¡Imagínese tener que descargar todo el catálogo de productos de Amazon en su propia computadora antes de poder navegar por él!
+
+## ¿Cómo ayuda?
+
+Al implementar la lógica de la aplicación en un servidor o servicio remoto,
+los operadores pueden actualizarlo sin necesidad de cambiar la lógica del lado del cliente.
+Esto significa que las actualizaciones se pueden realizar con mucha más frecuencia.
+El almacenamiento de datos en el servidor permite que muchos clientes vean y compartan los mismos datos.
+Considere la diferencia entre usar un procesador de textos en línea, en comparación con un procesador de textos tradicional fuera de línea.
+En el primero, sus archivos existen en el lado del servidor y
+se pueden compartir con otros usuarios que simplemente los descargan del servidor.
+En el mundo antiguo, los archivos debían copiarse en medios extraíbles (¡disquetes!) y compartirse con las personas.
diff --git a/content/es/cloud-computing.md b/content/es/cloud-computing.md
index dbeebe66cf..1a451f0c17 100644
--- a/content/es/cloud-computing.md
+++ b/content/es/cloud-computing.md
@@ -2,16 +2,26 @@
 title: Computación en la Nube
 status: Completed
 category: Concepto
+tags: ["infrastructure", "", ""]
 ---
 
 ## ¿Qué es?
 
-La computación en la nube es un modelo que ofrece recursos informáticos como capacidades de CPU, red y disco bajo demanda a través de Internet. La computación en la nube brinda a los usuarios la capacidad de acceder y utilizar el poder de cómputo en una ubicación física remota. Los proveedores de la nube como AWS, GCP, Azure, DigitalOcean y otros ofrecen a terceros la capacidad de alquilar el acceso a los recursos informáticos en múltiples ubicaciones geográficas.
+La computación en la nube es un modelo que ofrece recursos informáticos como capacidades de CPU, red y disco bajo demanda a través de Internet.
+La computación en la nube brinda a los usuarios la capacidad de acceder y utilizar el poder de cómputo en una ubicación física remota.
+Los proveedores de la nube como AWS, GCP, Azure, DigitalOcean y otros ofrecen a terceros
+la capacidad de alquilar el acceso a los recursos informáticos en múltiples ubicaciones geográficas.
 
 ## Problema que aborda
 
-Tradicionalmente, las organizaciones se enfrentaban a dos problemas principales cuando intentaban ampliar su poder de computo. Ellos adquieren, brindan soporte, diseñan y pagan instalaciones para alojar sus servidores físicos y su red o amplían y mantienen esas instalaciones. La computación en la nube permite a las organizaciones subcontratar una parte de sus necesidades informáticas a otra organización.
+Tradicionalmente, las organizaciones se enfrentaban a dos problemas principales cuando intentaban ampliar su poder de computo.
+Ellos adquieren, brindan soporte, diseñan y pagan instalaciones
+para alojar sus servidores físicos y su red o amplían y mantienen esas instalaciones.
+La computación en la nube permite a las organizaciones subcontratar una parte de sus necesidades informáticas a otra organización.
 
 ## ¿Cómo ayuda?
 
-Los proveedores de la nube ofrecen a las organizaciones la capacidad de alquilar recursos informáticos bajo demanda y pagar por el uso. Esto permite dos innovaciones principales: las organizaciones pueden probar cosas sin perder tiempo planificando y gastando dinero o recursos en nueva infraestructura física y pueden [escalar](/scalability/) según sea necesario y bajo demanda. La computación en la nube permite a las organizaciones adoptar tanta o tan poca infraestructura como necesiten.
+Los proveedores de la nube ofrecen a las organizaciones la capacidad de alquilar recursos informáticos bajo demanda y pagar por el uso.
+Esto permite dos innovaciones principales:
+las organizaciones pueden probar cosas sin perder tiempo planificando y gastando dinero o recursos en nueva infraestructura física y pueden [escalar](/scalability/) según sea necesario y bajo demanda.
+La computación en la nube permite a las organizaciones adoptar tanta o tan poca infraestructura como necesiten.
diff --git a/content/es/cloud-native-apps.md b/content/es/cloud-native-apps.md
new file mode 100644
index 0000000000..4b8b0d72db
--- /dev/null
+++ b/content/es/cloud-native-apps.md
@@ -0,0 +1,32 @@
+---
+title: Aplicaciones Nativas para la Nube
+status: Completed
+category: Concepto
+tags: ["application", "", ""]
+---
+
+## ¿Qué es?
+
+Las aplicaciones nativas para la nube están diseñadas específicamente para aprovechar las innovaciones en [computación en la nube](/es/cloud_computing/).
+Estas aplicaciones se integran fácilmente con sus respectivas arquitecturas en la nube,
+aprovechando los recursos de la nube y las capacidades de [escalado](/scalability/).
+También se refiere a las aplicaciones que aprovechan las innovaciones en infraestructura impulsadas por la computación en la nube.
+Las aplicaciones nativas para la nube de hoy en día incluyen aplicaciones que se ejecutan en el centro de datos de un proveedor de la nube y en plataformas nativas de la nube on-premises.
+
+## Problema que aborda
+
+Tradicionalmente, los entornos on-premises proporcionaban recursos informáticos de una manera bastante personalizada.
+Cada centro de datos tenía servicios que [acoplaban estrechamente](/tightly-coupled-architectures/) aplicaciones a entornos específicos,
+a menudo dependiendo en gran medida del aprovisionamiento manual de infraestructura, como [máquinas virtuales](/virtual_machine/) y servicios.
+Esto, a su vez, restringió a los desarrolladores y sus aplicaciones a ese centro de datos en específico.
+Las aplicaciones que no fueron diseñadas para la nube no pudieron aprovechar las capacidades de resiliencia y escalabilidad de un entorno de nube.
+Por ejemplo, las aplicaciones que requieren una intervención manual para iniciarse correctamente no pueden escalarse automáticamente,
+ni pueden reiniciarse automáticamente en caso de falla.
+
+## ¿Cómo ayuda?
+
+Si bien no existe una ruta única para las aplicaciones nativas para la nube, éstas sí tienen algunos puntos en común.
+Las aplicaciones nativas para la nube son resistentes, manejables y cuentan con la ayuda del conjunto de servicios en la nube que las acompañan.
+Los diversos servicios en la nube permiten un alto grado de [observabilidad](/es/observability/),
+permitiendo a los usuarios detectar y abordar problemas antes de que se agraven.
+Combinados con una sólida automatización, permiten a los ingenieros realizar cambios de alto impacto con frecuencia y de manera predecible con un esfuerzo mínimo.
diff --git a/content/es/cloud-native-security.md b/content/es/cloud-native-security.md
new file mode 100644
index 0000000000..5ba2013d80
--- /dev/null
+++ b/content/es/cloud-native-security.md
@@ -0,0 +1,33 @@
+---
+title: Seguridad Nativa para la Nube
+status: Completed
+category: Concepto
+tags: ["security", "", ""]
+---
+
+## ¿Qué es?
+
+La seguridad nativa para la nube es un enfoque que crea seguridad en las [aplicaciones nativas para la nube](/es/cloud-native-apps/).
+Garantiza que la seguridad sea parte de todo el ciclo de vida de la aplicación, desde el desarrollo hasta la producción.
+La seguridad nativa para la nube busca garantizar los mismos estándares que los modelos de seguridad tradicionales
+mientras se adapta a las particularidades de los entornos nativos para la nube,
+es decir, cambios rápidos de código e infraestructura altamente efímera.
+La seguridad nativa para la nube está muy relacionada con la práctica denominada [DevSecOps](/devsecops/).
+
+## Problema que aborda
+
+Los modelos de seguridad tradicionales se construyeron con una serie de suposiciones que ya no son válidas.
+Las aplicaciones nativas para la nube cambian con frecuencia, usan una gran cantidad de herramientas y bibliotecas de código abierto,
+a menudo se ejecutan en una infraestructura controlada por el proveedor y están sujetas a cambios rápidos en la infraestructura.
+Las revisiones de código, los ciclos prolongados de control de calidad, el análisis de vulnerabilidades basado en el servidor,
+y las revisiones de seguridad de última hora no pueden escalar con las aplicaciones nativas para la nube.
+
+## ¿Cómo ayuda?
+
+La seguridad nativa para la nube presenta una forma nueva de trabajar que protege las aplicaciones
+al migrar de los modelos de seguridad tradicionales a uno en el que la seguridad está involucrada en cada paso del ciclo de lanzamiento.
+Las auditorías y verificaciones manuales se reemplazan en gran medida con escaneos automatizados.
+Los flujos de liberación rápida de código están integrados con herramientas que escanean el código en busca de vulnerabilidades antes de que se compilen.
+Las bibliotecas de código abierto se extraen de fuentes confiables y se monitorean en busca de vulnerabilidades.
+En lugar de ralentizar el cambio, un modelo de seguridad nativo para la nube lo adopta
+mediante componentes vulnerables que se actualizan con frecuencia o garantiza que la infraestructura se reemplace periódicamente.
diff --git a/content/es/cloud-native-tech.md b/content/es/cloud-native-tech.md
new file mode 100644
index 0000000000..960c3b6ff0
--- /dev/null
+++ b/content/es/cloud-native-tech.md
@@ -0,0 +1,33 @@
+---
+title: Tecnología Nativa para la Nube
+status: Completed
+category: Concepto
+tags: ["fundamentals", "", ""]
+---
+
+## ¿Qué es?
+
+Las tecnologías nativas para la nube, también denominadas como stack nativo para la nube,
+son las tecnologías que se utilizan para crear [aplicaciones nativas para la nube](/es/cloud-native-apps/).
+Estas tecnologías permiten a las organizaciones crear y ejecutar aplicaciones escalables en entornos modernos y dinámicos
+como nubes públicas, privadas e híbridas,
+mientras aprovechan al máximo los beneficios de la [computación en la nube](/es/cloud_computing/).
+Están diseñadas desde cero para explotar las capacidades de la computación en la nube y los contenedores, las mallas de servicio, los microservicios,
+y la infraestructura inmutable ejemplifican este enfoque.
+
+## Problema que aborda
+
+El stack nativo para la nube tiene muchas categorías de tecnología diferentes, que abordan una variedad de desafíos.
+Si observa el [Panorama Nativo para la Nube de la CNCF](https://landscape.cncf.io/),
+verá cuántas áreas diferentes toca.
+Pero en un alto nivel, abordan un conjunto principal de desafíos:
+las desventajas de los modelos operativos de TI tradicionales.
+Los desafíos incluyen dificultades para crear aplicaciones escalables, tolerantes a fallas y autorreparables,
+así como la utilización ineficiente de recursos, entre otros.
+
+## ¿Cómo ayuda?
+
+Si bien cada tecnología aborda un problema muy específico,
+como grupo, las tecnologías nativas para la nube permiten sistemas poco acoplados que son resistentes, manejables y observables.
+Combinados con una sólida automatización, permiten a los ingenieros realizar cambios de alto impacto con frecuencia y de manera predecible con un esfuerzo mínimo.
+Las características deseables de los sistemas nativos para la nube son más fáciles de lograr con el stack nativo para la nube.
diff --git a/content/es/cluster.md b/content/es/cluster.md
new file mode 100644
index 0000000000..25c591b971
--- /dev/null
+++ b/content/es/cluster.md
@@ -0,0 +1,29 @@
+---
+title: Clúster
+status: Completed
+category: Concepto
+tags: ["infrastructure", "architecture", ""]
+---
+
+## ¿Qué es?
+
+Un clúster es un grupo de ordenadores o aplicaciones que trabajan juntos hacia un objetivo común.
+En el contexto de computación nativa en la nube, el término es aplicado con mayor frecuencia a [Kubernetes](/es/kubernetes/).
+Un clúster de Kubernetes es un conjunto de servicios (o cargas de trabajo) que son ejecutadas en sus propios contenedores, normalmente en ordenadores diferentes.
+El conjunto de todos estos servicios [contenedorizados](/es/containerization/), conectados a través de una red, representan un clúster.
+
+## Problema que aborda
+
+Un software que es ejecutado en un solo ordenador es un único punto de fallo
+— Si este ordenador falla, o alguien por accidente desconecta el cable de alimentación,
+algún sistema crítico para el negocio puede quedar fuera de funcionamiento.
+Es por esto que el software moderno se construye generalmente como [aplicaciones distribuidas](/distributed-apps), agrupadas en clústeres.
+
+## ¿Cómo ayuda?
+
+Las aplicaciones distribuidas en clúster se ejecutan en varias máquinas u ordenadores, eliminando un único punto de fallo.
+Pero construir sistemas distribuidos es difícil.
+De hecho, es una disciplina informática en sí misma.
+La necesidad de sistemas globales y los años de prueba y error llevaron al desarrollo de un nuevo tipo de stack de tecnología:
+[tecnologías nativas para la nube](/es/cloud-native-tech/).
+Estas nuevas tecnologías son los bloques de construcción que facilitan el funcionamiento y la creación de sistemas distribuidos.
diff --git a/content/es/container-image.md b/content/es/container-image.md
new file mode 100644
index 0000000000..6b58d783f3
--- /dev/null
+++ b/content/es/container-image.md
@@ -0,0 +1,30 @@
+---
+title: Imagen de contenedor
+status: Feedback Appreciated
+category: Concepto
+tags: ["", "", ""]
+---
+
+## ¿Qué es?
+
+Una imagen es un fichero estático e inmutable que contiene las dependencias para la creación de un [contenedor](/container/).
+Estas dependencias pueden incluir un archivo binario ejecutable, librerías del sistema,
+herramientas del sistema, variables de entorno y otras configuraciones de plataforma necesarias.
+Las imágenes son el resultado de la [contenerización](/es/containerization) de una aplicación y típicamente están guardadas en los registros de contenedor,
+donde pueden ser descargados para ser ejecutados como procesos aislados usando un Container Runtime Interface (CRI).
+El framework de una imagen debe de seguir el esquema estándar definido por el Open Container Initiative (OCI).
+
+## Problema que aborda
+
+Tradicionalmente, los servidores de aplicaciones utilizan configuración específica por entorno para que después las aplicaciones puedan ser desplegadas sobre ellos.
+Cualquier configuración errónea entre los entornos es problemática, a menudo traduciéndose en cortes del servicio o despliegues fallidos.
+Un entorno de aplicación tiene que ser fácil de replicar, además de estar bien definido;
+en caso contrario, la posibilidad de bugs y errores relacionados con el entorno aumenta.
+Cuando los entornos de aplicación no están configurados de manera adecuada o son inexactos,
+el escalado [horizontal](/horizontal-scaling/) y [vertical](/vertical-scaling/) de las aplicaciones se complica y reduce su efectividad.
+
+## ¿Cómo ayuda?
+
+Las imágenes empaquetan una aplicación con todas las dependencias necesarias para ejecutarse, como el servidor de aplicación.
+Esto otorga consistencia en todos los entornos, incluyendo los dispositivos locales de desarrollo.
+Una imagen puede dar lugar a cualquier número de contenedores, según sea necesario, permitiendo una mayor [escalabilidad](/scalability/).
diff --git a/content/es/containerization.md b/content/es/containerization.md
new file mode 100644
index 0000000000..fd083de294
--- /dev/null
+++ b/content/es/containerization.md
@@ -0,0 +1,32 @@
+---
+title: Contenerización
+status: Completed
+category: Tecnología
+tags: ["application", "", ""]
+---
+
+## ¿Qué es?
+
+La contenerización es el proceso que consiste en empaquetar una aplicación y sus dependencias en una [imagen de contenedor](/es/container-image/).
+La construcción del contenedor requiere del seguimiento del estándar [Open Container Initiative](https://opencontainers.org) (OCI).
+Mientras la salida de este proceso sea un contenedor de imagen que se adhiera a dicho estándar, la herramienta de contenerización usada no es relevante.
+
+## Problema que aborda
+
+Antes de que los contenedores fuesen relevantes, las organizaciones dependían de máquinas virtuales para
+orquestar múltiples aplicaciones en una única [máquina Bare Metal](/es/bare-metal-machine/).
+Las máquinas virtuales son significativamente más pesadas que los contenedores y requieren de un hipervisor para su funcionamiento.
+Debido al almacenamiento, copias de seguridad y transferencia de estas plantillas de máquinas virtuales, la creación de las mismas también se trata de un proceso lento.
+Adicionalmente, las máquinas virtuales pueden sufrir variaciones en la configuración, lo cuál contradice el principio de [inmutabilidad](/es/immutable-infrastructure/).
+
+## ¿Cómo ayuda?
+
+Al contrario que con las máquinas virtuales tradicionales, las imágenes de contenedor son ligeras y
+el proceso de contenerización requiere de una lista exhaustiva de dependencias.
+Este archivo puede ser versionado y el proceso de construcción automatizado,
+permitiendo a una organización centrarse en otras prioridades
+mientras que los procesos automatizados se encargan de la construcción.
+Una imagen de contenedor se almacena junto a un identificador único
+que está vinculado a un contenido y configuración exacta.
+Conforme los contenedores son programados y reprogramados,
+siempre van a ser revertidos a su estado inicial, lo cuál elimina variaciones en la configuración.
diff --git a/content/es/continuous-delivery.md b/content/es/continuous-delivery.md
new file mode 100644
index 0000000000..02cf63ce6b
--- /dev/null
+++ b/content/es/continuous-delivery.md
@@ -0,0 +1,37 @@
+---
+title: Entrega Continua (CD)
+status: Completed
+category: Concepto
+tags: ["application", "methodology", ""]
+---
+
+## ¿Qué es?
+
+La entrega continua, a menudo abreviada como CD, es un conjunto de prácticas
+en las que los cambios de código se despliegan automáticamente en un entorno de aceptación
+(o, en el caso de despliegue continuo, en producción).
+El CD incluye procedimientos cruciales para garantizar que el software se pruebe adecuadamente
+antes del despliegue y proporciona una forma de revertir los cambios si se considera necesario.
+La integración continua (CI) es el primer paso hacia la entrega continua
+(es decir, los cambios deben fusionarse limpiamente antes de probarse e implementarse).
+
+## Problema que aborda
+
+El despliegue de actualizaciones de [fiabilidad](/es/reliability/) se convierte en un problema a escala.
+Idealmente, desplegaríamos con más frecuencia para ofrecer un mejor valor a los usuarios finales.
+Sin embargo, hacerlo manualmente se traduce en altos costos por cada cambio.
+Históricamente, para evitar estos costos, las organizaciones liberaban con menos frecuencia,
+desplegaban más cambios a la vez y aumentaban el riesgo de que algo salga mal.
+
+## ¿Cómo ayuda?
+
+Las estrategias de CD crean una ruta totalmente automatizada hacia producción
+que prueba e implementa el software utilizando varias estrategias de despliegue,
+como las versiones [canary](/es/canary-deployment/) o [blue-green](/es/blue-green-deployment/).
+Esto permite a los desarrolladores implementar código con frecuencia, lo que les da la tranquilidad de saber que se ha probado la nueva revisión.
+Por lo general, el desarrollo basado en troncos (trunk-based development) se usa en estrategias de CD en lugar de ramificación de funciones o solicitudes de incorporación de cambios.
+
+## Términos relacionados
+
+* [Integración Continua](/es/continuous-integration/)
+* [Despliegue Continuo](/continuous_deployment/)
diff --git a/content/es/continuous-integration.md b/content/es/continuous-integration.md
new file mode 100644
index 0000000000..f780430452
--- /dev/null
+++ b/content/es/continuous-integration.md
@@ -0,0 +1,33 @@
+---
+title: Integración Continua (CI)
+status: Completed 
+category: Concepto
+tags: ["application", "methodology", ""]
+---
+
+## ¿Qué es?
+
+Integración continua, o por sus siglas en ingles CI, es la práctica de integrar cambios en el código lo más frecuente posible.
+CI es un requisito para la [entrega continua](/es/continuous-delivery/) (CD).
+Tradicionalmente, el proceso de CI comienza cuando se envían los cambios en el código hacia un sistema de control de versiones (Git, Mercurial, o Subversion)
+y termina con un artefacto testeado y listo para ser consumido por un sistema de CD.
+
+## Problema que aborda
+
+Los sistemas de software frecuentemente son grandes y complejos, con numerosos desarrolladores manteniéndolo y actualizándolo.
+Al trabajar en paralelo en diferentes partes del sistema,
+estos desarrolladores pueden hacer cambios conflictivos y romper inadvertidamente el trabajo de los demás.
+Además, con varios desarrolladores trabajando en el mismo proyecto,
+cualquier tarea cotidiana, como las pruebas y el cálculo de la calidad del código, tendría que ser repetida por cada desarrollador, lo que supone una pérdida de tiempo.
+
+## ¿Cómo ayuda?
+
+El software de CI comprueba automáticamente que los cambios en el código se fusionaron correctamente cada vez que un desarrollador envía un cambio.
+Es una práctica casi siempre presente el usar el servidor de CI para ejecutar las comprobaciones de calidad de código, pruebas, e incluso despliegues.
+Como tal, se convierte en una implementación concreta del control de calidad dentro de los equipos.
+CI permite que los equipos de software conviertan cada cambio de código en un fallo concreto o en un candidato a la publicación viable.
+
+## Términos relacionados
+
+* [Entrega Continua](/es/continuous-delivery/)
+* [Despliegue Continuo](/continuous-deployment/)
diff --git a/content/es/debugging.md b/content/es/debugging.md
new file mode 100644
index 0000000000..f04bca1e7a
--- /dev/null
+++ b/content/es/debugging.md
@@ -0,0 +1,29 @@
+---
+title: Depuración
+status: Completed
+category: concepto
+tags: ["application", "", ""]
+---
+
+## ¿Qué es?
+
+La depuración es el proceso o actividad de encontrar y resolver bugs (o errores) de programas, software o sistemas informáticos para obtener el resultado deseado.
+Un bug es un defecto o un problema que conduce a resultados incorrectos o inesperados.
+
+## Problema que aborda
+
+El desarrollo de software es una actividad compleja que hace que sea casi imposible escribir código sin introducir bugs.
+Esos bugs conducen a un código que probablemente no funcionará como se desea (un comportamiento no definido) cuando se ejecute.
+Dependiendo de que tan crítica sea una aplicación, los bugs pueden tener un impacto negativo significativo; financiero o incluso en vidas humanas.
+Por lo general, el código de una aplicación tiene que pasar por diferentes etapas o entornos en los que se prueba.
+Cuanto más crítica es una aplicación, más precisa debe ser la prueba.
+
+## ¿Cómo ayuda?
+
+Cuando aparecen bugs, los ingenieros tienen que depurar (p. ej., encontrar y reparar) la aplicación para disminuir el comportamiento no deseado de los sistemas de producción.
+La depuración no es una tarea fácil, ya que los ingenieros deben rastrear el origen del comportamiento no deseado.
+Requiere conocimiento sobre el código en sí y el contexto de ejecución en tiempo de ejecución.
+Aquí es donde las diferentes técnicas y herramientas de depuración resultan útiles.
+El análisis de registros, trazas y métricas, son un ejemplo de lo que se utiliza para la depuración directamente en producción.
+Los desarrolladores pueden usar la depuración interactiva para recorrer el código en tiempo de ejecución mientras analizan el contexto de ejecución relacionado.
+Una vez que han identificado el origen del error, corrigen el código y crean un bug fix o parche.
diff --git a/content/es/devops.md b/content/es/devops.md
index 5412f0bafa..b81d0a6742 100644
--- a/content/es/devops.md
+++ b/content/es/devops.md
@@ -2,18 +2,32 @@
 title: DevOps
 status: Completed
 category: Concepto
+tags: ["methodology", "", ""]
 ---
 
 ## ¿Qué es?
 
-DevOps es una metodología en la que los equipos son dueños de todo el proceso, desde el desarrollo de la aplicación hasta las operaciones en producción, de ahí el término DevOps. Va más allá de implementar un conjunto de tecnologías y requiere un cambio completo en la cultura y los procesos. DevOps requiere grupos de ingenieros que trabajen en componentes pequeños (en lugar de una función completa), reduciendo las transferencias, una fuente común de errores.
+DevOps es una metodología en la que los equipos son dueños de todo el proceso, desde el desarrollo de la aplicación hasta las operaciones en producción, de ahí el término DevOps.
+Va más allá de implementar un conjunto de tecnologías y requiere un cambio completo en la cultura y los procesos.
+DevOps requiere grupos de ingenieros que trabajen en componentes pequeños (en lugar de una función completa), reduciendo las transferencias, una fuente común de errores.
 
 ## Problema que aborda
 
-Tradicionalmente, en organizaciones complejas con [aplicaciones monolíticas](/monolithic-apps/) con arquitecturas [estrechamente acopladas](/tightly-coupled-architectures/), el trabajo generalmente se distribuía entre varios equipos. Esta fragmentación del desarrollo dio lugar a numerosos traspasos y largos plazos de entrega. Cada vez que un componente o alguna actualización estaba lista, se colocaba en una cola para el siguiente equipo. Debido a que las personas solo trabajaron en una pequeña parte del proyecto, este enfoque condujo a una falta de propiedad. Su objetivo era entregar el trabajo al siguiente grupo, en vez de ofrecer la funcionalidad correcta al cliente - un claro desajuste de prioridades.
+Tradicionalmente, en organizaciones complejas con [aplicaciones monolíticas](/monolithic-apps/) con arquitecturas [estrechamente acopladas](/tightly-coupled-architectures/),
+el trabajo generalmente se distribuía entre varios equipos.
+Esta fragmentación del desarrollo dio lugar a numerosos traspasos y largos plazos de entrega.
+Cada vez que un componente o alguna actualización estaba lista, se colocaba en una cola para el siguiente equipo.
+Debido a que las personas solo trabajaron en una pequeña parte del proyecto, este enfoque condujo a una falta de propiedad.
+Su objetivo era entregar el trabajo al siguiente grupo, en vez de ofrecer la funcionalidad correcta al cliente
+- un claro desajuste de prioridades.
 
-Cuando el código finalmente entró en producción, pasó por tantos desarrolladores, esperando en tantas colas que era difícil rastrear el origen del problema si el código no funcionaba. DevOps dio la vuelta a este enfoque.
+Cuando el código finalmente entró en producción, pasó por tantos desarrolladores,
+esperando en tantas colas que era difícil rastrear el origen del problema si el código no funcionaba.
+DevOps dio la vuelta a este enfoque.
 
 ## ¿Cómo ayuda?
 
-Tener un equipo que es dueño de todo el ciclo de vida de una aplicación tiene como resultado transferencias minimizadas, reduce el riesgo de implementación en producción, mejora la calidad del código ya que los equipos también son responsables del código ejecutado en producción y aumenta la satisfacción de los empleados debido a una mayor autonomía y propiedad.
+Tener un equipo que es dueño de todo el ciclo de vida de una aplicación tiene como resultado
+transferencias minimizadas, reduce el riesgo de implementación en producción, mejora la calidad del código
+ya que los equipos también son responsables del código ejecutado en producción
+y aumenta la satisfacción de los empleados debido a una mayor autonomía y propiedad.
diff --git a/content/es/digital-certificate.md b/content/es/digital-certificate.md
new file mode 100644
index 0000000000..79c8fd4b3a
--- /dev/null
+++ b/content/es/digital-certificate.md
@@ -0,0 +1,25 @@
+---
+title: Certificado Digital
+status: Feedback Appreciated
+category: Tecnología
+---
+
+## ¿Qué es?
+
+Un certificado (digital), también conocido como certificado de clave pública o certificado SSL(Secure Sockets Layer), es un documento digital utilizado para ayudar a proteger las comunicaciones que ocurren a través de la red.
+Los certificados nos permiten conocer la entidad en particular con la que nos estamos comunicando y si es quien dice ser.
+También nos permiten asegurarnos de que nuestras comunicaciones sean privadas al cifrar los datos que enviamos y recibimos.
+
+## Problema que aborda
+
+Cuando los dispositivos se comunican a través de una red, no existe una garantía inherente de que un dispositivo en particular sea quien dice ser.
+Además, no podemos garantizar que el tráfico entre dos dispositivos no sea interceptado por un tercero.
+En consecuencia, cualquier comunicación puede ser potencialmente interceptada, comprometiendo información confidencial como nombres de usuario y contraseñas.
+
+## ¿Cómo ayuda?
+
+Los clientes de correo electrónico modernos que utilizan certificados pueden notificar si la identidad del remitente es correcta, al igual que los navegadores web (vea el pequeño candado frente a la barra de direcciones en su navegador web).
+Por otro lado, los certificados se pueden usar para cifrar la comunicación entre entidades en Internet.
+Proporcionan una técnica de cifrado que hace que sea casi imposible que alguien que intercepte la comunicación y pueda leer los datos.
+
+## Términos relacionados
\ No newline at end of file
diff --git a/content/es/event-driven-architecture.md b/content/es/event-driven-architecture.md
new file mode 100644
index 0000000000..2e4cfa179a
--- /dev/null
+++ b/content/es/event-driven-architecture.md
@@ -0,0 +1,25 @@
+---
+title: Arquitectura Basada en Eventos
+status: Completed
+category: Concepto
+---
+
+## ¿Qué es?
+
+La arquitectura basada en eventos es una arquitectura de software que promueve la creación, procesamiento y consumo de eventos.
+Un evento es cualquier cambio en el estado de una aplicación.
+Por ejemplo, solicitar un viaje en una aplicación de viajes compartidos es un evento.
+Esta arquitectura crea la estructura en la cual los eventos pueden ser enviados desde su origen (la aplicación solicitando el viaje) a los receptores deseados (las aplicaciones de conductores cercanos).
+
+## Problema que aborda
+
+Mientras más datos son convertidos en tiempo real, encontrar maneras fiables de asegurar que los eventos son capturados y dirigidos al [servicio](/service/) apropiado para procesar solicitudes de eventos se hace más difícil.
+Los métodos tradicionales para manejar eventos comúnmente no tienen una manera de garantizar que los eventos son dirigidos apropiadamente o que realmente fueron enviados o recibidos.
+Mientras las aplicaciones comienzan a escalar, se hace más desafiante orquestar eventos.
+
+## ¿Cómo ayuda?
+
+Las arquitecturas basadas en eventos establecen un centro para todos los eventos (por ejemplo, Kafka).
+Luego se definen productores de eventos (origen) y consumidores (receptores), y luego el centro de eventos garantiza el flujo de dichos eventos.
+Esta arquitectura se asegura de que los servicios permanezcan desacoplados y que los eventos son debidamente enviados desde el productor al consumidor.
+El productor toma un evento entrante, normalmente mediante un protocolo HTTP, para luego enviar la información del evento.
diff --git a/content/es/event-streaming.md b/content/es/event-streaming.md
new file mode 100644
index 0000000000..142c14fbe4
--- /dev/null
+++ b/content/es/event-streaming.md
@@ -0,0 +1,30 @@
+---
+title: Transmisión de eventos
+status: Completed
+category: Concepto
+---
+
+## ¿Qué es?
+
+La transmisión de eventos es un enfoque en el que el software envía datos de eventos de una aplicación a otra para comunicar continuamente lo que esta haciendo.
+Imagine un servicio transmitiendo todo lo que hace a todos los demás servicios.
+Cada actividad realizada por un servicio se denomina evento, por lo tanto, transmisión de eventos.
+Por ejemplo, NASDAQ recibe actualizaciones sobre los precios de las acciones y materias primas cada segundo.
+Si tuviera una aplicación que monitoreará un conjunto específico de acciones, le gustaría recibir esa información casi en tiempo real.
+Yahoo! Finance proporciona una [API](/es/application-programming-interface/) que extrae de NASDAQ y envía (o transmite) la información (o eventos) de su aplicación a cualquier aplicación que se suscriba a ella.
+Los datos que se envían, así como los cambios en esos datos (precios de las acciones), son los eventos, mientras que el proceso de enviarlos a una aplicación es la transmisión de eventos.
+
+## Problema que aborda
+
+Tradicionalmente, Yahoo! Finance usaría solicitudes TCP únicas.
+Esto sería muy ineficiente ya que requeriría la creación de una conexión para cada evento.
+En medida que los datos se vuelven más en tiempo real, escalar una solución de este tipo se vuelve ineficiente.
+Abrir una conexión solo una vez y permitir que los eventos fluyan, es ideal para la recopilación en tiempo real.
+La cantidad de datos que se generan está creciendo exponencialmente y, con eso, el estado de los datos está en constante cambio. Los desarrolladores y usuarios deben poder ver esos datos casi en tiempo real.
+
+## ¿Cómo ayuda?
+
+La transmisión de eventos permite que los cambios de datos se comuniquen desde la fuente al receptor.
+En lugar de esperar a que los servicios soliciten información, el servicio transmite continuamente todos sus eventos (o actividades).
+No le preocupa lo que sucede con la información.
+Simplemente hace lo que tiene que hacer y lo transmite, permaneciendo así completamente independiente de cualquier otro servicio.
diff --git a/content/es/gitops.md b/content/es/gitops.md
new file mode 100644
index 0000000000..a0077eee57
--- /dev/null
+++ b/content/es/gitops.md
@@ -0,0 +1,31 @@
+---
+title: GitOps
+status: Feedback Appreciated
+category: Concepto
+tags: ["", "", ""]
+---
+
+## ¿Qué es?
+
+GitOps es un conjunto de buenas prácticas basadas en unos [principios comunes](https://opengitops.dev/),
+aplicados a un flujo de trabajo que depende de agentes de software que
+de forma automática reconcilian las configuraciones o el estado de un sistema respecto al estado o las configuraciones declaradas en un repositorio git.
+Tanto los agentes de software, como las prácticas, son utilizados para ejecutar flujos de trabajo consistentes que
+aprovechan los sistemas de control de versiones como Git, definiéndolos como "única fuente de verdad" y
+extiende esta practica a las distintas capas de un sistema, tales como las aplicaciones, la infraestructura y los procedimientos operativos.
+
+## Problema que aborda
+
+Los procesos de gestión de la configuración de la infraestructura se enfrentan a desafíos
+como las diferencias en la configuración, los despliegues fallidos, la necesidad de confiar en el estado anterior del sistema como garantía de éxito,
+la falta de documentación o una desconocida historia de desarrollo.
+Adoptar un flujo de trabajo GitOps puede ayudar a solventar estos problemas, entre muchos otros.
+
+## ¿Cómo ayuda?
+
+GitOps es un paradigma que puede aplicarse a un flujo de trabajo
+para ayudar a gestionar tanto una aplicación como la infraestructura de un sistema en la nube.
+GitOps proporciona varias ventajas a las organizaciones
+que lo implementan, como una mejor coordinación, mayor transparencia, más estabilidad y una mayor fiabilidad de sus sistemas.
+Los agentes de software GitOps operan en un *bucle de control (control loop)* que garantiza que el estado actual del sistema coincida
+con el estado deseado que está especificado en un repositorio git.
diff --git a/content/es/idempotence.md b/content/es/idempotence.md
new file mode 100644
index 0000000000..9034c77d8c
--- /dev/null
+++ b/content/es/idempotence.md
@@ -0,0 +1,10 @@
+---
+title: Idempotencia
+status: Completed
+category: Propiedad
+tags: ["infrastructure", "architecture", ""]
+---
+
+En matemáticas o informática, la idempotencia describe una operación que siempre conduce al mismo resultado,
+no importa cuantas veces se ejecute.
+Si los parámetros son los mismos, una operación idempotente no afectará a la aplicación a la que llama.
diff --git a/content/es/immutable-infrastructure.md b/content/es/immutable-infrastructure.md
new file mode 100644
index 0000000000..018738186b
--- /dev/null
+++ b/content/es/immutable-infrastructure.md
@@ -0,0 +1,25 @@
+---
+title: Infraestructura inmutable
+status: Completed
+category: Propiedad
+tags: ["infrastructure", "", ""]
+---
+
+Infraestructura inmutable se refiere a la infraestructura informática
+([máquinas virtuales](/virtual-machine/), [contenedores](/container/), dispositivos de red)
+que no se puede cambiar una vez implementada.
+Esto se puede hacer cumplir mediante un proceso automatizado que sobreescriba los cambios no autorizados o
+a través de un sistema que no permita cambios en primer lugar.
+Los contenedores son un buen ejemplo de infraestructura inmutable
+porque los cambios persistentes en los contenedores solo pueden ser realizados por
+la creación una nueva versión del contenedor o recreando el contenedor existente a partir de su imagen.
+
+Al prevenir o identificar cambios no autorizados,
+las infraestructuras inmutables facilitan la identificación y mitigación de los riesgos de seguridad.
+Operar un sistema de este tipo se vuelve mucho más sencillo
+porque los administradores pueden hacer suposiciones al respecto.
+Después de todo, saben que nadie cometió errores o cambios que se olvidaron de comunicar.
+La infraestructura inmutable va de la mano con [infraestructura como código](/es/infrastructure-as-code/)
+donde toda la automatización necesaria para crear la infraestructura se almacena en el control de versiones (por ejemplo, Git).
+Esta combinación de inmutabilidad y control de versiones significa que
+existe un registro de auditoría duradero de cada cambio autorizado en un sistema.
diff --git a/content/es/infrastructure-as-a-service.md b/content/es/infrastructure-as-a-service.md
new file mode 100644
index 0000000000..44818d85fc
--- /dev/null
+++ b/content/es/infrastructure-as-a-service.md
@@ -0,0 +1,21 @@
+---
+title: Infraestructura como Servicio (IaaS)
+status: Completed
+category: Tecnología
+---
+
+## ¿Qué es?
+
+Infraestructura como Servicio, o IaaS, es un modelo de servicio de [computación en la nube](/es/cloud_computing/) que ofrece recursos de cómputo, almacenamiento y red mediante servidores [físicos](/es/bare_metal_machine/) o [virtualizados](/virtualization/) suministrados bajo demanda en un modelo de pago por uso. Los proveedores de la nube poseen y operan el hardware y el software, a disposición de los consumidores en despliegues de nube pública, privada o híbrida.
+
+
+## Problema que aborda
+
+En las configuraciones tradicionales de On-prem, las organizaciones suelen tener dificultades para utilizar eficazmente sus recursos de computación. Los centros de datos son construidos para soportar potenciales picos de demanda, aunque estos solo ocurren el 1% del tiempo. Cuando la demanda es menor, estos recursos de computación están sin uso. Y, si la carga de trabajo se dispara más allá de la demanda prevista, hay una escasez de recursos de computación para procesar la carga de trabajo. Esta falta de escalabilidad provoca un aumento de los costes y un uso poco eficaz de los recursos.
+
+
+## ¿Cómo ayuda?
+
+Mediante IaaS las organizaciones pueden evitar la compra y el mantenimiento de recursos de computación y de espacio en los centros de datos para ejecutar sus aplicaciones. Una infraestructura bajo demanda les permite alquilar recursos de computación según sus necesidades y aplazar los grandes gastos de capital, o [CAPEX](https://es.wikipedia.org/wiki/Capex), a la vez que les da la flexibilidad de aumentar o reducir su uso.
+
+IaaS reduce los costes iniciales de experimentar o probar una aplicación nueva y proporciona facilidades para desplegar rápidamente la infraestructura. Un proveedor de la nube es una excelente opción para entornos de desarrollo o de prueba, lo que ayuda a los desarrolladores a experimentar e innovar.
diff --git a/content/es/infrastructure-as-code.md b/content/es/infrastructure-as-code.md
index 6d2743f0e2..01a3d4adea 100644
--- a/content/es/infrastructure-as-code.md
+++ b/content/es/infrastructure-as-code.md
@@ -2,16 +2,25 @@
 title: Infraestructura como Código (IaC)
 status: Completed
 category: Concepto
+tags: ["infrastructure", "", ""]
 ---
 
 ## ¿Qué es?
 
-Infraestructura como código es una práctica para almacenar la definición de la infraestructura en uno o varios archivos. Esto reemplaza el modelo tradicional dónde la infraestructura como servicio es aprovisionado de forma manual, por lo general usando scripts con la consola u otras herramientas de configuración.
+Infraestructura como código es una práctica para almacenar la definición de la infraestructura en uno o varios archivos.
+Esto reemplaza el modelo tradicional dónde la infraestructura como servicio es aprovisionado de forma manual,
+por lo general usando scripts con la consola u otras herramientas de configuración.
 
 ## Problema que aborda
 
-Construir aplicaciones de forma nativa para la nube requiere que la infraestructura sea desechable y reproducible. Además requiere [escalar](/scalability/) bajo demanda de forma automática y repetible, potencialmente sin la intervención humana. El aprovisionamiento manual no puede cumplir los requerimientos de respuesta y escalado de las [aplicaciones nativas para la nube](/cloud-native-apps/). Los cambios manuales no son reproducibles, rápidamente se enfrentan a limites de escalabilidad, e introducen errores de configuración.
+Construir aplicaciones de forma nativa para la nube requiere que la infraestructura sea desechable y reproducible.
+Además requiere [escalar](/scalability/) bajo demanda de forma automática y repetible, potencialmente sin la intervención humana.
+El aprovisionamiento manual no puede cumplir los requerimientos de respuesta y escalado de las [aplicaciones nativas para la nube](/es/cloud-native-apps/).
+Los cambios manuales no son reproducibles, rápidamente se enfrentan a limites de escalabilidad, e introducen errores de configuración.
 
 ## ¿Cómo ayuda?
 
-Representados los recursos del [centro de datos](/data-center/) tales como servidores, balanceadores de carga y sub-redes como código, les permite a los equipos de infraestructura poseer una fuente única de verdad para todas las configuraciones y también les permite administrar sus [centro de datos](/data-center/) en flujos de [CI](/continuous-integration/)/[CD](/continuous-delivery/) implementando un sistema de control de versiones y estrategias de despliegue.
+Representados los recursos del [centro de datos](/data-center/) tales como servidores, balanceadores de carga y sub-redes como código,
+les permite a los equipos de infraestructura poseer una fuente única de verdad para todas las configuraciones y
+también les permite administrar sus [centro de datos](/data-center/) en flujos de [CI](/es/continuous-integration/)/[CD](/continuous-delivery/)
+implementando un sistema de control de versiones y estrategias de despliegue.
diff --git a/content/es/kubernetes.md b/content/es/kubernetes.md
index 06e1525447..b1e22698e3 100644
--- a/content/es/kubernetes.md
+++ b/content/es/kubernetes.md
@@ -2,26 +2,34 @@
 title: Kubernetes
 status: Completed
 category: Tecnología
+tags: ["infrastructure", "", ""]
 ---
 
 ## ¿Qué es?
 
-Kubernetes, comúnmente abreviado como K8s, es una herramienta de código abierto para la automatización de infraestructura moderna. Puedes compararlo con un sistema operativo en un Centro de Datos que administra las aplicaciones ejecutándose en [sistemas distribuidos](/distributed-systems/) (ó como el sistema operativo en tu laptop que administra tus aplicaciones).
+Kubernetes, comúnmente abreviado como K8s, es un orquestador de contenedores de código abierto.
+Automatiza el ciclo de vida de las aplicaciones contenedorizadas en infraestructuras modernas, funcionando como un "sistema operativo en un Centro de Datos" que administra las aplicaciones ejecutándose en [sistemas distribuidos](/distributed-systems/).
 
-Kubernetes gestiona [contenedores](/container/) en los [nodos](/nodes/) de un [clúster](/cluster/). Agrupa muchos componentes de infraestructura, en ocasiones referidos como "primitivos", como una instancia de una aplicación, balanceadores de carga, almacenamiento persistente y otros, de manera que puedan integrarse en aplicaciones.
+Kubernetes gestiona [contenedores](/container/) en los [nodos](/nodes/) de un [clúster](/es/cluster/), agrupa muchos componentes de infraestructura, en ocasiones referidos como "primitivos", como una instancia de una aplicación, balanceadores de carga, almacenamiento persistente y otros, de manera que puedan integrarse en aplicaciones.
 
-Kubernetes permite la automatización y extensibilidad, permitiendo a los usuarios desplegar sus aplicaciones de una manera declarativa y reproducible. Los productos de Software en el Ecosistema de Kubernetes toman ventaja de la automatización para extender la [API](/application-programming-interface/) de Kubernetes. Lo que permite aprovechar la automatización de Kubernetes y hacer que sus herramientas sean más accesibles para profesionistas experimentados de Kubernetes.
+Kubernetes permite la automatización y extensibilidad, permitiendo a los usuarios desplegar sus aplicaciones de una manera declarativa y reproducible.
+Kubernetes puede ser extendido a través de su [API](/es/application-programming-interface/), permitiendo aprovechar la automatización de Kubernetes y hacer que sus herramientas sean más accesibles para profesionistas experimentados de Kubernetes.
 
 ## Problema que aborda
 
-La automatización de infraestructura y administración de configuración declarativa han sido conceptos muy importantes por un largo tiempo, y han sumado más importancia desde que la [Computación en la Nube](/es/cloud-computing/) ha ganado popularidad. La demanda de recursos de cómputo incrementa día con día y las organizaciones sienten presión por proveer más capacidad operativa, con menos ingenieros. Para cumplir con esta demanda nuevas tecnologías y metodologías de trabajo deben ser creadas.
-
-Además, el auge de la computación en la nube se combinó con la [contenerización](/containerization/) y las organizaciones que estaban ocupadas automatizando una infraestructura tradicional necesitaban un mecanismo para automatizar la configuración y el despliegue de sus contenedores.
+La automatización de infraestructura y administración de configuración declarativa han sido conceptos muy importantes por un largo tiempo, y han sumado más importancia desde que la [Computación en la Nube](/es/cloud-computing/) ha ganado popularidad.
+La demanda de recursos de cómputo incrementa día con día y las organizaciones sienten presión por proveer más capacidad operativa, con pocos ingenieros, nuevas tecnologías y metodologías de trabajo deben ser creadas para satisfacer esta demanda.
 
 ## ¿Cómo ayuda?
 
-Kubernetes ayuda con la automatización de una manera similar a las herramientas tradicionales de Infraestructura como Código, pero tiene la ventaja de trabajar con contenedores que son más resistentes a fallas por diferencias en entornos a comparación con las máquinas virtuales o físicas.
+De manera parecida a las herramientas tradicionales de [infraestructura como código](/es/infrastructure-as-code/), Kubernetes ayuda con la automatización pero tiene la ventaja de trabajar con contenedores.
+Los contenedores son más resistentes a fallas por diferencias en entornos a comparación con las [máquinas virtuales](/virtual-machine/) o físicas.
 
-Kubernetes funciona declarativamente, lo que significa que, en lugar de que los operadores proporcionen las instrucciones sobre cómo realizar una acción, ellos describen, por lo general en archivos de manifiesto (por ejemplo, YAML), lo que quieren que se logre; Kubernetes se encargará del "cómo" por sí mismo. Esto da como resultado que Kubernetes sea extremadamente compatible con la Infraestructura como Código.
+Aún más, Kubernetes funciona declarativamente, lo que significa que, en lugar de que los operadores proporcionen las instrucciones sobre cómo realizar una acción, ellos describen, por lo general en archivos de manifiesto (por ejemplo, YAML), lo que quieren que se logre;
+Kubernetes se encargará del "cómo" por sí mismo.
+Esto da como resultado que Kubernetes sea extremadamente compatible con la Infraestructura como Código.
 
-Kubernetes también se autocura. Esto significa que garantiza que el estado real del [clúster](/cluster/) siempre coincida con el estado deseado por el operador. Si Kubernetes detecta una desviación del estado deseado, un controlador de Kubernetes será invocado para corregirlo. Así que, aunque la infraestructura cambie continuamente, Kubernetes en sí mismo se adaptará continuamente y automáticamente a los cambios y asegurará de que coincida con el estado deseado.
+Kubernetes también se [autocura](/self-healing/).
+Esto significa que garantiza que el estado real del clúster siempre coincida con el estado deseado por el operador.
+Si Kubernetes detecta una desviación del estado deseado, un controlador de Kubernetes será invocado para corregirlo.
+Así que, aunque la infraestructura cambie continuamente, Kubernetes en sí mismo se adaptará continuamente y automáticamente a los cambios y asegurará de que coincida con el estado deseado.
diff --git a/content/es/managed-services.md b/content/es/managed-services.md
new file mode 100644
index 0000000000..2ce319b7c4
--- /dev/null
+++ b/content/es/managed-services.md
@@ -0,0 +1,22 @@
+---
+title: Servicios Administrados
+status: Completed
+category: Tecnología
+tags: ["", "", ""]
+---
+
+## ¿Qué es?
+
+Un servicio administrado es una solución de software en la que las operaciones y gestión son manejadas por un tercero.
+Algunos ejemplos incluyen Bases de Datos como Servicio como Amazon RDS o un servicio de monitoreo externo como Datadog.
+
+## Problema que aborda
+
+La gestión del software es compleja, especialmente si consideramos todas las tecnologías diferentes que componen un stack moderno.
+Gestionar cada uno de los aspectos y/o contar con expertos internos capaces de hacerlo puede ser demasiado costoso o no utilizar el tiempo de los ingenieros eficientemente.
+Es probable que tu equipo esté mejor construyendo nuevas capacidades que ocupándose de tareas operativas que pueden ser fácilmente subcontratadas.
+
+## ¿Cómo ayuda?
+
+Los servicios administrados están listos para ser utilizados desde el primer día de implementación, con muy pocos gastos operativos.
+Permiten a las organizaciones externalizar eficientemente las tareas que no forman parte de su rubro principal con límites bien definidos y, por lo general impulsados por la [API](/es/application-programming-interface/).
diff --git a/content/es/platform-as-a-service.md b/content/es/platform-as-a-service.md
new file mode 100644
index 0000000000..64ff54d0f4
--- /dev/null
+++ b/content/es/platform-as-a-service.md
@@ -0,0 +1,24 @@
+---
+title: Plataforma como Servicio (PaaS)
+status: Completed
+category: Tecnología
+tags: ["fundamentals", "platform", ""]
+---
+
+## ¿Qué es?
+
+Una plataforma como servicio, o PaaS, es una plataforma externa usada por los equipos de desarrollo de aplicaciones para desplegar y correr sus aplicaciones.
+Heroku, Cloud Foundry y App Engine son ejemplos de ofertas de PaaS.
+
+## Problema que aborda
+
+Para aprovechar los patrones de las aplicaciones nativas para la nube como son los [microservicios](/microservices/) o las [aplicaciones distribuidas](/distributed-apps/),
+los equipos de operaciones y los desarrolladores necesitan ser capaces de descargar un tiempo significativo de trabajo en operaciones y mantenimiento.
+Estos incluyen tareas como el aprovisionamiento de infraestructura,
+el manejo del [descubrimiento de servicios](/service-discovery/) y balanceo de cargas, y [escalamiento](/scalability/) de aplicaciones.
+
+## ¿Cómo ayuda?
+
+Una solución PaaS ofrece herramientas de infraestructura comunes, a los desarrolladores de aplicaciones de forma totalmente automatizada.
+Permite que los desarrolladores puedan comprender y preocuparse menos por la infraestructura y así dedicar mas tiempo en escribir código de la aplicación.
+También proporciona cierta supervisión y [observabilidad](/es/observability/) para ayudar a los equipos de aplicaciones a garantizar que sus aplicaciones estén en buen estado.
diff --git a/content/es/policy-as-code.md b/content/es/policy-as-code.md
new file mode 100644
index 0000000000..76f853f1f2
--- /dev/null
+++ b/content/es/policy-as-code.md
@@ -0,0 +1,26 @@
+---
+title: Política como código (PaC)
+status: Feedback Appreciated
+category: Concepto
+tags: ["", "", ""]
+---
+
+## ¿Qué es?
+
+Política como código es la práctica de almacenar la definición de políticas en uno o más archivos de manera que se pueda procesar y sea legible por máquina.
+Esto reemplaza el modelo tradicional en el que las políticas se documentan en forma legible por humanos, en documentos separados.
+
+## Problema que aborda
+
+La creación de aplicaciones e infraestructuras a menudo está limitada por muchas políticas definidas por una organización,
+p.ej. políticas de seguridad que prohíben almacenar secretos en el código fuente,
+para ejecutar un contenedor con permisos de superusuario o para almacenar algunos datos fuera de una región geográfica específica.
+Se requiere de mucha mano de obra y es propenso a errores para los desarrolladores y revisores
+verificar manualmente las aplicaciones e infraestructura contra las políticas documentadas.
+La verificación manual de las políticas no puede cumplir con los requisitos de capacidad de respuesta y escala de las aplicaciones nativas para la nube.
+
+## ¿Cómo ayuda?
+
+Al usar Política como código, es posible automatizar la verificación de las propiedades y acciones del sistema.
+Las mejores prácticas de desarrollo de software se pueden aplicar a la creación de políticas como código,
+p.ej. mediante el uso de Git y los flujos de trabajo asociados.
diff --git a/content/es/portability.md b/content/es/portability.md
new file mode 100644
index 0000000000..51429b8677
--- /dev/null
+++ b/content/es/portability.md
@@ -0,0 +1,9 @@
+---
+title: Portabilidad
+status: Completed
+category: Propiedad
+---
+
+La portabilidad es una característica del software, siendo una forma de reutilización que ayuda a evitar el "bloqueo" de ciertos entornos operativos, p.ej. proveedores de nube, sistemas operativos o vendedores.
+
+Tradicionalmente, el software es construido para entornos específicos (p. ej. AWS o Linux). El software portable, por otro lado, funciona en diferentes entornos operativos sin necesidad de una adaptación importante. Una aplicación se considera portable si el esfuerzo requerido para adaptarla a un nuevo entorno está dentro de límites razonables. La frase "portar" significa modificar el software y hacerlo adaptable para trabajar en diferentes sistemas informáticos.
\ No newline at end of file
diff --git a/content/es/reliability.md b/content/es/reliability.md
new file mode 100644
index 0000000000..183b08adac
--- /dev/null
+++ b/content/es/reliability.md
@@ -0,0 +1,13 @@
+---
+title: Fiabilidad
+status: Completed
+category: Propiedad
+tags: ["fundamentals", "", ""]
+---
+
+## ¿Qué es?
+
+Desde una perspectiva nativa a la nube, fiabilidad se refiere a qué tan bien un sistema responde ante las fallas. 
+Si tenemos un [sistema distribuido](/distributed-systems/) que continúa funcionando mientras la infraestructura cambia y los componentes individuales fallan, este es fiable. 
+Por otro lado, si falla fácilmente y los operadores deben intervenir manualmente para mantenerlo en ejecución, entonces es poco confiable. 
+La meta de las [aplicaciones nativas para la nube](/es/cloud-native-apps/) es construir sistemas inherentemente fiables.
\ No newline at end of file
diff --git a/content/hi/_index.md b/content/hi/_index.md
index eccf9f22fd..f149008503 100644
--- a/content/hi/_index.md
+++ b/content/hi/_index.md
@@ -1,5 +1,6 @@
 ---
 title: क्लाउड नेटिव शब्दावली
+status: Completed
 ---
 
 # क्लाउड नेटिव शब्दावली
diff --git a/content/it/_index.md b/content/it/_index.md
index 48ebd8807b..2425b46131 100644
--- a/content/it/_index.md
+++ b/content/it/_index.md
@@ -1,5 +1,6 @@
 ---
 title: "Glossario Cloud Native"
+status: Completed
 ---
 
 # Glossario Cloud Native
diff --git a/content/ko/_index.md b/content/ko/_index.md
index c4931b2bdc..93ff878d71 100644
--- a/content/ko/_index.md
+++ b/content/ko/_index.md
@@ -1,5 +1,6 @@
 ---
 title: "클라우드 네이티브 용어집"
+status: Completed
 ---
 
 # 클라우드 네이티브 용어집
diff --git a/content/pt-br/_index.md b/content/pt-br/_index.md
index d9d9106341..07dc3875e4 100755
--- a/content/pt-br/_index.md
+++ b/content/pt-br/_index.md
@@ -1,5 +1,6 @@
 ---
 title: "Glossário Cloud Native"
+status: Completed
 ---
 
 # Glossário Cloud Native
diff --git a/content/zh-cn/_index.md b/content/zh-cn/_index.md
index f60f9f7a02..e2889b599b 100644
--- a/content/zh-cn/_index.md
+++ b/content/zh-cn/_index.md
@@ -1,5 +1,6 @@
 ---
 title: "云原生词汇表"
+status: Completed
 ---
 
 # 云原生词汇表
diff --git a/content/zh-cn/api-gateway.md b/content/zh-cn/api-gateway.md
index 7f276797fe..159606f3d5 100644
--- a/content/zh-cn/api-gateway.md
+++ b/content/zh-cn/api-gateway.md
@@ -21,6 +21,5 @@ API 网关是一种通过聚合多个应用程序的 [API](/zh-cn/application-pr
 
 通过为多个 API 提供一个统一的访问入口，API 网关能够让组织更容易地将交叉性业务或安全性逻辑移交到一个可集中管理的地方。
 应用的消费端也只需要访问单个地址就可以满足其所有需求。
-
 通过为系统中的所有 web 服务提供统一的访问入口，API 网关还可以简化诸如安全性和[可观测性](/observability/)之类的运维问题。
 由于所有请求都流经 API 网关，因此它可以中心化的为这些请求添加诸如指标收集、速率限制和授权等功能。
diff --git a/content/zh-cn/bare-metal-machine.md b/content/zh-cn/bare-metal-machine.md
index ed454cb28e..ef9b2532fc 100644
--- a/content/zh-cn/bare-metal-machine.md
+++ b/content/zh-cn/bare-metal-machine.md
@@ -2,6 +2,7 @@
 title: 裸机
 status: Completed
 category: 技术
+tags: ["基础设施", "", ""]
 ---
 
 ## 是什么
diff --git a/content/zh-cn/chaos-engineering.md b/content/zh-cn/chaos-engineering.md
index c337e26567..448ed0c768 100644
--- a/content/zh-cn/chaos-engineering.md
+++ b/content/zh-cn/chaos-engineering.md
@@ -7,12 +7,12 @@ tags: ["安全", "", ""]
 
 ## 是什么
 
-混沌工程或 CE 是在生产中对 [分布式系统](/distributed-systems/) 进行实验的学科，以建立对系统承受动荡和意外情况时能力的信心。
+混沌工程或 CE 是在生产中对 [分布式系统](/zh-cn/distributed-systems/) 进行实验的学科，以建立对系统承受动荡和意外情况时能力的信心。
 
 ## 解决的问题
 
-[SRE](/site_reliability_engineering/) 和 [DevOps](/devops/) 实践侧重于提高产品弹性和 [可靠性](/reliability/) 的技术。
-系统在故障容灾时确保服务质量的能力通常是对软件开发提出的要求。这里涉及到几个方面可能导致应用程序中断，例如基础设施、平台或（基于[微服务](/microservices/)）的应用程序的其他部分。
+[SRE](/zh-cn/site_reliability_engineering/) 和 [DevOps](/zh-cn/devops/) 实践侧重于提高产品弹性和 [可靠性](/zh-cn/reliability/) 的技术。
+系统在故障容灾时确保服务质量的能力通常是对软件开发提出的要求。这里涉及到几个方面可能导致应用程序中断，例如基础设施、平台或（基于[微服务](/zh-cn/microservices/)）的应用程序的其他部分。
 高频地持续部署新功能到生产环境会增加服务中断和恶性事件发生的可能性，乃至于对业务产生重大影响。
 
 ## 如何帮助
diff --git a/content/zh-cn/cloud-native-apps.md b/content/zh-cn/cloud-native-apps.md
index d0b1c12417..35a7f58546 100644
--- a/content/zh-cn/cloud-native-apps.md
+++ b/content/zh-cn/cloud-native-apps.md
@@ -15,7 +15,7 @@ tags: ["应用程序", "", ""]
 ## 解决的问题
 
 传统上，本地环境以相当定制的方式提供计算资源。
-每个数据中心都有与特定环境 [紧密耦合](/tightly-coupled-architectures/) 应用程序的服务，通常严重依赖于基础设施的手动配置，例如 [虚拟机](/zh-cn/virtual-machine/) 和服务。
+每个数据中心都有与特定环境 [紧密耦合](/zh-cn/tightly-coupled-architectures/) 应用程序的服务，通常严重依赖于基础设施的手动配置，例如 [虚拟机](/zh-cn/virtual-machine/) 和服务。
 这反过来又将开发人员及其应用程序限制在该特定数据中心。
 不是为云设计的应用程序无法利用云环境的弹性和伸缩能力。
 例如，需要手动干预才能正确启动的应用程序无法自动伸缩，也无法在发生故障时自动重启。
diff --git a/content/zh-cn/container-orchestration.md b/content/zh-cn/container-orchestration.md
new file mode 100644
index 0000000000..8458ca1c76
--- /dev/null
+++ b/content/zh-cn/container-orchestration.md
@@ -0,0 +1,24 @@
+---
+title: 容器编排
+status: Completed
+category: 概念
+---
+
+## 是什么
+
+[容器](/zh-cn/container/)编排指的是在动态的环境中自动管理容器化应用的生命周期。
+这通过一个容器编排器（大多是 [Kubernetes](/zh-cn/kubernetes)）来执行，实现部署、（自动）扩缩、自愈和监控。
+编排是一个比喻用词：编排工具像乐队指挥一样指挥众多容器，确保每个容器（或乐手）各行其是。
+
+## 解决的问题
+
+手动管理大规模的[微服务](/zh-cn/microservices)、安全性和网络通信
+（及常见的[分布式系统](/zh-cn/distributed-systems)）即使并非不可能，亦会非常困难。
+而容器编排能让用户自动化处理所有这些管理任务。
+
+## 如何帮助
+
+容器编排工具允许用户确定系统的状态。
+首先，这些工具会声明系统应具备的框架（例如 x 个容器、y 个 Pod 等）。
+然后，编排工具将自动监控基础设施，并在其状态偏离声明的状态时对其进行修正（例如如果一个容器崩溃，则启动一个新的容器）。
+这种自动化作业精简了许多工程团队原本需要大量手动完成的复杂运营任务，例如制备、部署、扩缩容、联网、负载均衡和其他活动。
diff --git a/content/zh-cn/containerization.md b/content/zh-cn/containerization.md
index 534f5b2aa5..b3a5660b07 100644
--- a/content/zh-cn/containerization.md
+++ b/content/zh-cn/containerization.md
@@ -7,19 +7,19 @@ tags: ["应用程序", "", ""]
 
 ## 是什么
 
-容器化是将一个应用程序及其依赖关系捆绑到 [容器图像](/zh-cn/container-image/) 中的过程。
+容器化是将一个应用程序及其依赖关系捆绑到 [容器镜像](/zh-cn/container-image/) 中的过程。
 容器构建过程需要遵守 [开放容器倡议](https://opencontainers.org)(OCI) 标准。
 只要输出的是一个符合这个标准的容器镜像，使用哪种容器化工具并不重要。
 
-## 解决的问题 
+## 解决的问题
 
-在容器盛行之前，企业依靠虚拟机 (VMs) 在一台 [裸机](/bare-metal-machine/) 上协调多个应用程序。
+在容器盛行之前，企业依靠虚拟机 (VMs) 在一台 [裸机](/zh-cn/bare-metal-machine/) 上协调多个应用程序。
 虚拟机比容器大得多，需要一个管理程序来运行。由于这些较大的虚拟机模板的存储、备份和传输，创建虚拟机模板也很慢。
-此外，虚拟机可能会出现配置漂移，这违反了 [不变性](/immutable-infrastructure/) 的原则。
+此外，虚拟机可能会出现配置漂移，这违反了 [不变性](/zh-cn/immutable-infrastructure/) 的原则。
 
 ## 如何帮助
 
-容器图像是轻量级的（与传统的虚拟机不同），容器化过程需要一个带有依赖性列表的文件。
+容器镜像是轻量级的（与传统的虚拟机不同），容器化过程需要一个带有依赖性列表的文件。
 这个文件可以被版本控制，构建过程也可以自动化，允许一个组织在自动化过程中关注其他优先事项。
 容器镜像由一个唯一的标识符来存储，该标识符与它的确切内容和配置相联系。
 当容器被安排和重新安排时，它们总是被重置为其初始状态，从而消除了配置漂移。
diff --git a/content/zh-cn/containers-as-a-service.md b/content/zh-cn/containers-as-a-service.md
index f783e0c8b7..7aa457b0b2 100644
--- a/content/zh-cn/containers-as-a-service.md
+++ b/content/zh-cn/containers-as-a-service.md
@@ -1,5 +1,5 @@
 ---
-title: 容器即服务
+title: 容器即服务 (CaaS)
 status: Completed
 category: 技术
 tags: ["平台", "", ""]
@@ -7,7 +7,7 @@ tags: ["平台", "", ""]
 
 ## 是什么
 
-容器即服务（CaaS）是一种云服务，有助于使用基于 [容器](/zh-cn/container/) 的 [抽象](/abstraction/) 管理和部署应用程序。
+容器即服务（CaaS）是一种云服务，有助于使用基于 [容器](/zh-cn/container/) 的 [抽象](/zh-cn/abstraction/) 管理和部署应用程序。
 这项服务可以部署在企业内部或云中。
 
 CaaS 供应商提供了一个框架或协调平台，使容器部署和管理的关键 IT 功能自动化。
diff --git a/content/zh-cn/devops.md b/content/zh-cn/devops.md
index 2df2ad6875..4f10d37124 100644
--- a/content/zh-cn/devops.md
+++ b/content/zh-cn/devops.md
@@ -12,7 +12,7 @@ DevOps 需要一组工程师来处理小组件（相对于整个功能），从
 
 ## 解决的问题
 
-传统上，在具有 [紧密耦合](/tightly-coupled-architectures/) [单体应用程序](/zh-cn/monolithic_apps/) 的复杂组织中，工作通常分散在多个组之间。
+传统上，在具有 [紧密耦合](/zh-cn/tightly-coupled-architectures/) [单体应用程序](/zh-cn/monolithic_apps/) 的复杂组织中，工作通常分散在多个组之间。
 这导致了多次交接和较长的交货时间。 每次组件或更新准备就绪时，都会将其放入队列中以供下一个团队使用。
 因为个人只参与了项目的一小部分，这种方法导致缺乏所有权。 他们的目标是将工作交给下一个小组，而不是为客户提供正确的功能——明显的优先级错位。
 
diff --git a/content/zh-cn/distributed-systems.md b/content/zh-cn/distributed-systems.md
index b698226e8c..a09eba0205 100644
--- a/content/zh-cn/distributed-systems.md
+++ b/content/zh-cn/distributed-systems.md
@@ -8,7 +8,7 @@ tags: ["架构", "", ""]
 ## 是什么
 
 分布式系统是通过网络连接的自主计算元素的集合，在用户看来是一个单一的连贯系统。
-一般被称为 [节点](/nodes/)，这些组件可以是硬件设备（如电脑、手机）或软件进程。
+一般被称为 [节点](/zh-cn/nodes/)，这些组件可以是硬件设备（如电脑、手机）或软件进程。
 节点被编程以实现一个共同的目标，为了协作，它们通过网络交换信息。
 
 ## 解决的问题
diff --git a/content/zh-cn/event-driven-architecture.md b/content/zh-cn/event-driven-architecture.md
new file mode 100644
index 0000000000..47a16068b1
--- /dev/null
+++ b/content/zh-cn/event-driven-architecture.md
@@ -0,0 +1,25 @@
+---
+title: 事件驱动架构
+status: Completed
+category: 概念
+---
+
+## 是什么
+
+事件驱动架构是一种提倡事件的创建、处理和消费的软件架构。
+事件是对应用程序状态的任何更改。
+例如，在拼车应用上叫车代表一个事件。
+这种架构创建了一个结构，在该结构中，事件可以从它们的源（请求乘车的应用程序）正确地路由到所需的接收器（附近可用司机的应用程序）。
+
+## 解决的问题
+
+随着越来越多的数据变得实时，寻找可靠的方法来确保捕获事件并将其路由到必须处理事件请求的适当[服务](/zh-cn/service/)变得越来越具有挑战性。
+处理事件的传统方法通常无法保证消息被恰当地路由或发送或接收。
+随着应用程序的扩展，编排事件变得更具挑战性。
+
+## 如何帮助
+
+事件驱动架构为所有事件建立了一个中心枢纽（例如，Kafka）。
+然后定义事件生产者（源）和消费者（接收者），中心事件枢纽保证事件的流动。
+这种架构确保服务保持解耦，并且事件从生产者正确路由到消费者。
+生产者通常通过 HTTP 协议接收传入事件，然后路由事件信息。
diff --git a/content/zh-cn/horizontal-scaling.md b/content/zh-cn/horizontal-scaling.md
index 2c3957f72c..f7d845c2c9 100644
--- a/content/zh-cn/horizontal-scaling.md
+++ b/content/zh-cn/horizontal-scaling.md
@@ -7,10 +7,10 @@ tags: ["基础设施", "", ""]
 
 ## 是什么
 
-水平伸缩是一种通过添加更多[节点](/nodes/)来增加系统容量的技术，而不是向单个节点添加更多计算资源（后者称为[垂直伸缩](/zh-cn/vertical-scaling/)）。
+水平伸缩是一种通过添加更多[节点](/zh-cn/nodes/)来增加系统容量的技术，而不是向单个节点添加更多计算资源（后者称为[垂直伸缩](/zh-cn/vertical-scaling/)）。
 假设我们有一个 4GB RAM 的系统，并且想要将其容量增加到 16GB RAM，水平伸缩意味着通过添加 4 x 4GB RAM 而不是切换到 16GB RAM 系统来实现。
 
-这种方法通过添加新实例或[节点](/nodes/)来提高应用程序的性能，以更好地均衡工作负载。
+这种方法通过添加新实例或[节点](/zh-cn/nodes/)来提高应用程序的性能，以更好地均衡工作负载。
 简而言之，它旨在减少服务器的负载，而不是扩大单个服务器的容量。
 
 ## 解决的问题
diff --git a/content/zh-cn/infrastructure-as-a-service.md b/content/zh-cn/infrastructure-as-a-service.md
index 2707ba35ec..653c2212af 100644
--- a/content/zh-cn/infrastructure-as-a-service.md
+++ b/content/zh-cn/infrastructure-as-a-service.md
@@ -1,5 +1,5 @@
 ---
-title: 基础设施即代码 (IaaS)
+title: 基础设施即服务 (IaaS)
 status: Completed
 category: 技术
 tags: ["基础设施", "", ""]
@@ -7,8 +7,8 @@ tags: ["基础设施", "", ""]
 
 ## 是什么
 
-基础设施即代码，或者 IaaS ，是一种 [云计算](/zh-cn/cloud-computing/) 服务模型，
-它提供 [物理](/bare-metal-machine/) 或 [虚拟](/zh-cn/virtualization/) 的计算、存储和网络资源，使用按需按量的计费模式。
+基础设施即服务，或者 IaaS ，是一种 [云计算](/zh-cn/cloud-computing/) 服务模型，
+它提供 [物理](/zh-cn/bare-metal-machine/) 或 [虚拟](/zh-cn/virtualization/) 的计算、存储和网络资源，使用按需按量的计费模式。
 云提供商拥有和管理软件和硬件设施，可供消费者在公共、私有或混合云部署和使用。
 
 ## 解决的问题
@@ -16,7 +16,6 @@ tags: ["基础设施", "", ""]
 在搭建传统的本地设施时，组织常常受困于如何保证资源的有效利用。
 数据中心建立时必须考虑潜在的高峰需求，即使这样的需求只占1%的使用时间。
 而在低需求期间，这些计算资源是空闲的。
-
 而且，如果工作负载超过预期需求，处理工作负载的计算资源则会出现短缺。
 这种缺乏可伸缩性的使用方式，将导致成本增加和资源使用率降低。
 
diff --git a/content/zh-cn/infrastructure-as-code.md b/content/zh-cn/infrastructure-as-code.md
index 495c8c912a..c5a87c821d 100644
--- a/content/zh-cn/infrastructure-as-code.md
+++ b/content/zh-cn/infrastructure-as-code.md
@@ -1,5 +1,5 @@
 ---
-title: 基础设施即代码
+title: 基础设施即代码 (IaC)
 status: Completed
 category: 概念
 tags: ["基础设施", "", ""]
@@ -13,13 +13,13 @@ tags: ["基础设施", "", ""]
 ## 解决的问题
 
 云原生方式构建应用程序要求基础设施是一次性的和可复现的。
-它还需要以自动化和可重复的方式按需 [伸缩](/scalability/)，甚至可能无需人工干预。
-手动配置则无法满足 [云原生应用](/cloud_native_apps/) 对响应能力和灵活伸缩的诉求。
+它还需要以自动化和可重复的方式按需 [伸缩](/zh-cn/scalability/)，甚至可能无需人工干预。
+手动配置则无法满足 [云原生应用](/zh-cn/cloud_native_apps/) 对响应能力和灵活伸缩的诉求。
 而且手动基础架构变更不可复现，很容易碰到伸缩瓶颈，并引入错误配置。
 
 ## 如何帮助
 
 通过将服务器、负载均衡器和子网等数据中心资源表示为代码，
-它允许基础架构团队对所有配置拥有单一的数据源，并允许他们在 
-[CI](/continuous-integration/ )/[CD](/continuous-delivery/) 
+它允许基础架构团队对所有配置拥有单一的数据源，并允许他们在
+[CI](/zh-cn/continuous-integration/ )/[CD](/zh-cn/continuous-delivery/)
 通道中管理数据中心，实现版本控制和部署策略。
diff --git a/content/zh-cn/kubernetes.md b/content/zh-cn/kubernetes.md
index eb7eb22228..b344be018a 100644
--- a/content/zh-cn/kubernetes.md
+++ b/content/zh-cn/kubernetes.md
@@ -10,7 +10,7 @@ tags: ["基础设施", "", ""]
 Kubernetes，通常缩写为K8s，是一种流行的现代基础设施自动化的开源工具。
 它就像一个数据中心的操作系统，管理在 [分布式系统](/zh-cn/distributed-systems/) 上运行的应用程序（就像你笔记本上的操作系统，管理你的应用程序）。
 
-Kubernetes在 [集群](/zh-cn/cluster/) 的 [节点](/nodes/) 上调度 [容器](/zh-cn/container/)。
+Kubernetes在 [集群](/zh-cn/cluster/) 的 [节点](/zh-cn/nodes/) 上调度 [容器](/zh-cn/container/)。
 它捆绑了几个基础设施结构，有时被称为 "基元"，如应用程序的实例、负载平衡器、持久性存储等，以一种可以被组成应用程序的方式。
 
 Kubernetes 实现了自动化和可扩展性，使用户能够以可重复的方式声明性地部署应用程序。
diff --git a/content/zh-cn/managed-services.md b/content/zh-cn/managed-services.md
new file mode 100644
index 0000000000..1761be3509
--- /dev/null
+++ b/content/zh-cn/managed-services.md
@@ -0,0 +1,23 @@
+---
+title: 托管服务
+status: Completed
+category: 技术
+tags: ["", "", ""]
+---
+
+## 是什么
+
+托管服务是一种软件产品，其运营和管理由第三方负责。
+例如类似 Amazon RDS 的数据库即服务或类似 Datadog 的外部监控服务。
+
+## 解决的问题
+
+软件的管理比较复杂，尤其是要考虑现代技术栈所包含的各种不同技术。
+而想要将管理做到面面俱到并招募能胜任此职的内部专家，要么成本过于高昂，要么会耗用工程师的宝贵时间。
+你的团队应投入精力构建新功能，而不是处理可以通过外包就能轻松解决的运营任务。
+
+## 如何帮助
+
+托管服务从一开始就处于使用就绪状态，运营开销非常小。
+托管服务具备良好定义的、通常由 [API](/zh-cn/application-programming-interface/) 驱动的边界，
+便于各个组织将超出其核心竞争力的任务有效外包出去。
diff --git a/content/zh-cn/microservices.md b/content/zh-cn/microservices.md
index 1f2cef7d87..122b18e41e 100644
--- a/content/zh-cn/microservices.md
+++ b/content/zh-cn/microservices.md
@@ -16,7 +16,7 @@ tags: ["架构", "", ""]
 微服务是对单体应用所带来的挑战的一种回应。一般来说，一个应用程序的不同部分需要分别进行 [伸缩](/zh-cn/scalability/)。
 例如，一个在线商店将有更多的产品视图而不是结账。这意味着你需要更多的产品视图功能的运行，而不是结账。
 在一个单一的应用程序中，这些逻辑位不能被单独部署。如果你不能单独扩展产品功能，你将不得不复制整个应用程序和所有其他你不需要的组件--这是一种低效的资源利用。
-单机式应用程序也使开发人员容易屈服于设计陷阱。因为所有的代码都在一个地方，所以更容易使这些代码 [高耦合](/tightly-coupled-architectures/)，更难执行关注点分离的原则。
+单机式应用程序也使开发人员容易屈服于设计陷阱。因为所有的代码都在一个地方，所以更容易使这些代码 [高耦合](/zh-cn/tightly-coupled-architectures/)，更难执行关注点分离的原则。
 单机通常要求开发人员了解整个代码库，然后才能有成效。
 
 ## 如何帮助
diff --git a/content/zh-cn/mutual-transport-layer-security.md b/content/zh-cn/mutual-transport-layer-security.md
new file mode 100644
index 0000000000..5086eb3e97
--- /dev/null
+++ b/content/zh-cn/mutual-transport-layer-security.md
@@ -0,0 +1,25 @@
+---
+title: 双向传输层安全性协议（mTLS）
+status: Completed
+category: 概念
+tags: ["安全", "", ""]
+---
+
+## 是什么
+
+双向 TLS (mTLS) 是一种用于对两个[服务](/zh-cn/service/)之间发送的消息进行身份验证和加密的技术。 
+双向 TLS (mTLS) 是标准的[传输层安全性协议](/zh-cn/transport-layer-security/)(TLS) ， 
+但不是仅验证一个连接的身份，而是验证双方。
+
+## 解决的问题
+
+[微服务](/zh-cn/microservices/)通过网络进行通信， 
+就像您的 wifi 网络一样，通过该网络传输的通信可能会被黑客入侵。 
+mTLS 确保没有未经授权的一方监听或冒充合法请求。
+
+## 如何帮助
+
+mTLS 确保客户端和服务器之间的双向流量是安全和可信的， 
+为进入网络或应用程序的用户提供了额外的安全层。 
+它还验证不遵循登录过程的客户端设备连接，例如物联网 (IoT) 设备。 
+mTLS 可以防止诸如路径上的攻击、欺骗攻击、凭证填充、暴力攻击等攻击。
diff --git a/content/zh-cn/observability.md b/content/zh-cn/observability.md
new file mode 100644
index 0000000000..23b6cb1d8b
--- /dev/null
+++ b/content/zh-cn/observability.md
@@ -0,0 +1,27 @@
+---
+title: 可观测性
+status: Completed
+category: 概念
+tags: ["方法论", "应用程序", "基础设施"]
+---
+
+## 是什么
+
+可观测性指的是从所观测的系统采集信号，持续生成并发现可执行的洞察力。
+换言之，可观测性允许用户从某个系统的外部输出中洞察该系统的状态并采取（修正）措施。
+
+## 解决的问题
+
+计算机系统的衡量机制为观测 CPU 时间、内存、磁盘空间等底层信号以及每秒
+API 响应次数、每秒错误率、每秒处理的事务数等高级信号和业务信号。
+
+系统的可观测性对其运营和开发成本有重大影响。
+可观测系统为操作人员提供了有意义的、可执行的数据，使他们能够达成有利的结果
+（即更快的事件响应、更高的开发效率）以及更少的艰辛时刻和更短的停机时间。
+
+## 如何帮助
+
+请注意，更多的信息并不一定能转化为可观测性更好的系统。
+事实上，有时系统生成的大量信息会形成信息噪音，会使得鉴别有价值的健康信号变得更加困难。
+可观测性需要在合适的时间为合适的消费者（一个人或一个软件）提供合适的数据，从而做出合适的决策。
+
diff --git a/content/zh-cn/platform-as-a-service.md b/content/zh-cn/platform-as-a-service.md
index dcfc793017..db9a758735 100644
--- a/content/zh-cn/platform-as-a-service.md
+++ b/content/zh-cn/platform-as-a-service.md
@@ -13,7 +13,7 @@ Heroku、Cloud Foundry、App Engine 是 PaaS 产品的示例。
 ## 解决的问题
 
 要利用好 [微服务](/zh-cn/microservices/) 或 [分布式应用程序](/zh-cn/distributed-apps/) 等云原生模式，
-运维团队和开发人员需要能够免去大量运维工作， 其中包括供应基础设施、处理[服务发现](/service-discovery/) 和
+运维团队和开发人员需要能够免去大量运维工作， 其中包括供应基础设施、处理[服务发现](/zh-cn/service-discovery/) 和
 负载平衡以及[扩展](/zh-cn/scalability/) 应用程序等任务。
 
 ## 如何帮助
diff --git a/content/zh-cn/policy-as-code.md b/content/zh-cn/policy-as-code.md
new file mode 100644
index 0000000000..11cf4347ed
--- /dev/null
+++ b/content/zh-cn/policy-as-code.md
@@ -0,0 +1,23 @@
+---
+title: 策略即代码 (PaC)
+status: Feedback Appreciated
+category: 概念
+tags: ["", "", ""]
+---
+
+## 是什么
+
+策略即代码是将一些策略的定义存储为一个或多个机器可读和可处理格式文件的做法。
+这取代了在传统模型中，以人类可读的形式记录在单独文档中的策略。
+
+## 解决的问题
+
+构建应用和基础设施通常受到某组织所定义的许多策略的约束，
+例如禁止在源代码中存储 Secret、禁止以超级用户权限运行容器或禁止将某些数据存储在特定地理区域之外的安全策略。
+对于开发人员和审查人员来说，按照策略文档手动检查应用和基础设施既耗时费力又容易出错。
+手动检查策略无法满足云原生应用的响应要求和扩缩要求。
+
+## 如何帮助
+
+通过使用策略即代码，可以自动检查系统属性和操作。
+软件开发的最佳实践也适用于构建策略即代码，例如使用 Git 及相关工作流。
diff --git a/content/zh-cn/portability.md b/content/zh-cn/portability.md
new file mode 100644
index 0000000000..90e50f2c96
--- /dev/null
+++ b/content/zh-cn/portability.md
@@ -0,0 +1,14 @@
+---
+title: 可移植性
+status: Completed
+category: 属性
+tags: ["基本原理", "", ""]
+---
+
+可移植性是一种软件特征，一种可重用性的形式，有助于避免“锁定”到某些操作环境，
+例如云提供商、操作系统或供应商。
+
+传统软件通常是为特定环境（例如 AWS 或 Linux）构建的。
+而可移植软件可以在不同的操作环境中工作，无需大量返工。
+如果应用适配新环境所需的工作量在合理范围内，则该应用被认为是可移植的。
+“移植”这个词意味着修改软件并使其适应在不同的计算机系统上工作。
\ No newline at end of file
diff --git a/content/zh-cn/scalability.md b/content/zh-cn/scalability.md
index fda6e77a42..588e08a348 100644
--- a/content/zh-cn/scalability.md
+++ b/content/zh-cn/scalability.md
@@ -7,9 +7,9 @@ tags: ["基本原理", "", ""]
 
 可伸缩性指的是一个系统能有多大的发展。这就是增加做任何系统应该做的事情的能力。
 例如，[Kubernetes](/zh-cn/kubernetes/) [集群](/zh/cluster/) 通过增加或减少 [容器化](/zh-cn/containerization/) 应用程序的数量来进行伸缩，但这种可伸缩性取决于几个因素。
-它有多少[节点](/nodes/)，每个节点可以处理多少个[容器](/zh-cn/container/)，控制平面可以支持多少条记录和操作？
+它有多少[节点](/zh-cn/nodes/)，每个节点可以处理多少个[容器](/zh-cn/container/)，控制平面可以支持多少条记录和操作？
 
 可伸缩的系统使添加更多容量更容易。主要有两种缩放方法。
-一方面，有 [水平伸缩](/horizontal-scaling/) 添加更多节点来处理增加的负载。
-相比之下，在 [垂直伸缩](/vertical-scaling/) 中，单个节点的功能更强大，可以执行更多事务（例如，通过向单个机器添加更多内存或 CPU）。
+一方面，有 [水平伸缩](/zh-cn/horizontal-scaling/) 添加更多节点来处理增加的负载。
+相比之下，在 [垂直伸缩](/zh-cn/vertical-scaling/) 中，单个节点的功能更强大，可以执行更多事务（例如，通过向单个机器添加更多内存或 CPU）。
 可伸缩的系统能够轻松更改并满足用户需求。
diff --git a/content/zh-cn/security-chaos-engineering.md b/content/zh-cn/security-chaos-engineering.md
index 68669f40a4..3b3a2b20c7 100644
--- a/content/zh-cn/security-chaos-engineering.md
+++ b/content/zh-cn/security-chaos-engineering.md
@@ -11,7 +11,7 @@ tags: ["安全", "", ""]
 
 ## 解决的问题
 
-[网站稳定性工程师](/site-reliability-engineering/)（SRE） 和网络安全工程师的主要职责是尽快恢复服务，来达到零停机时间和最小化业务影响的目标。 SRE 和网络安全工程师共同处理故障前和故障后的各种意外情况。大多数安全问题很难快速发现和修补，这将影响应用程序或系统的功能。此外，在开发阶段通常很难发现安全事件。
+[网站稳定性工程师](/zh-cn/site-reliability-engineering/)（SRE） 和网络安全工程师的主要职责是尽快恢复服务，来达到零停机时间和最小化业务影响的目标。 SRE 和网络安全工程师共同处理故障前和故障后的各种意外情况。大多数安全问题很难快速发现和修补，这将影响应用程序或系统的功能。此外，在开发阶段通常很难发现安全事件。
 
 ## 如何帮助
 
diff --git a/content/zh-cn/service.md b/content/zh-cn/service.md
new file mode 100644
index 0000000000..f1644a3016
--- /dev/null
+++ b/content/zh-cn/service.md
@@ -0,0 +1,12 @@
+---
+title: 服务
+status: Completed
+category: 概念
+tags: ["架构", "", ""]
+---
+
+请注意，在 IT 中，服务有多种含义。
+在这个定义中，我们将关注更传统的定义：微服务中的服务。
+服务与微服务哪里有、是否有区别是细微的，不同的人可能有不同的看法。
+在更高层次的定义中，我们将它们视为相同。
+请参考[微服务](/zh-cn/microservices/)的定义。
diff --git a/content/zh-cn/software-as-a-service.md b/content/zh-cn/software-as-a-service.md
new file mode 100644
index 0000000000..4966d7db2d
--- /dev/null
+++ b/content/zh-cn/software-as-a-service.md
@@ -0,0 +1,28 @@
+---
+Title: 软件即服务 (SaaS)
+Status: Completed
+Category: 技术
+tags: ["基本原理", "平台", ""]
+---
+
+## 是什么
+
+软件即服务 (SaaS) 允许用户通过互联网连接或使用云服务。
+常见的例子有电邮、日历和办公工具（例如 Gmail、AWS、GitHub、Slack）。
+SaaS 以按需付费的方式提供完整的软件解决方案。
+所有运维任务和应用数据由服务提供商处理。
+
+## 解决的问题
+
+传统的商业软件被安装在独立的计算机上，需要管理员维护和更新。
+例如：某组织可能在企业内部使用客户关系管理 (CRM) 软件。
+该软件需要内部 IT 部门采购、安装、确保安全、维护和定期升级，为 IT 团队增加了负担。
+与许可证、安装和潜在附加硬件相关的前期成本可能令人望而却步。
+也很难按需响应，很难随着业务增长或变化快速[扩缩](/zh-cn/scalability/)。
+
+## 如何帮助
+
+SaaS 应用无需内部 IT 部门付出任何特别努力即可工作。
+这些应用由供应商安装、维护、升级和确保安全。
+扩缩、可用性和容量问题由服务提供商处理，采用按需付费的模式。
+对于想要使用企业级应用的各个组织而言，SaaS 是一种经济实惠的方式。
diff --git a/content/zh-cn/stateful-apps.md b/content/zh-cn/stateful-apps.md
new file mode 100644
index 0000000000..ee04c5d73e
--- /dev/null
+++ b/content/zh-cn/stateful-apps.md
@@ -0,0 +1,28 @@
+---
+title: 有状态应用
+status: Completed
+category: 概念
+tags: ["基本原理", "", ""]
+---
+
+## 是什么
+
+当我们说到有状态（和[无状态](/zh-cn/stateless-apps/)）应用时，
+状态是指应用需要存储以便其按设计运行的任何数据。
+例如，任何能记住您购物车的在线商店都是有状态应用。
+
+## 解决的问题
+
+使用一个应用通常需要多个请求。
+例如，使用网上银行时，您将通过输入密码（请求 #1）来验证自己的身份，
+然后您可以将钱转给某个朋友（请求 #2），最后您需要查看转账详情（请求 #3）。
+为了保证正常运行，每一步都必须记住前面的步骤，银行需要记住每个人的账户状态。
+今天我们使用的大多数应用至少总有一部分是有状态的，
+因为这些应用会存储诸如偏好和设置之类的东西以改善用户体验。
+
+## 如何帮助
+
+有几种方法可以为有状态应用存储状态。
+最简单的是将状态保存在内存中，而不是将其持久保存在任何其他地方。
+这样做的问题是，每次应用必须重启时，所有状态都会丢失。
+为了防止这种情况发生，状态被持久存储在本地（磁盘上）或数据库系统中。
diff --git a/content/zh-cn/stateless-apps.md b/content/zh-cn/stateless-apps.md
new file mode 100644
index 0000000000..d00ca8074e
--- /dev/null
+++ b/content/zh-cn/stateless-apps.md
@@ -0,0 +1,30 @@
+---
+title: 无状态应用
+status: Feedback Appreciated
+category: 技术
+tags: ["基本原理", "", ""]
+---
+
+## 是什么
+
+无状态应用不会在应用所在的服务器上保存任何客户端会话（状态）数据。
+每个会话都像第一次一样执行，响应不依赖于前一个会话的数据并提供使用打印服务、内容分发网络（CDN）或
+Web 服务器的功能，以处理每个短期请求。
+例如，有人在搜索引擎中搜索某个问题并按下了回车键。
+如果搜索操作由于某种原因被中断或关闭，您必须重新开始一个新的，因为您之前的请求没有保存数据。
+
+## 解决的问题
+
+无状态应用解决了弹性问题，因为[集群](/zh-cn/cluster/)中的不同 Pod 可以独立工作，
+同时允许多个请求到达这些 Pod。
+如果应用出现故障，您只需重启应用，就能恢复到初始状态，停机时间很短或没有停机时间。
+因此，无状态应用的好处包括坚韧、弹性和高可用性。
+然而，我们今天使用的大多数应用至少总有一部分是[有状态的](/zh-cn/stateful-apps/)，
+因为它们会存储诸如偏好和设置之类的东西以改善用户体验。
+
+## 如何帮助
+
+归根结底，在无状态应用中集群唯一负责的是托管在其上的代码和其他静态内容。
+就是这样，不更改数据库，没有写入，删除 Pod 时也没有留下文件。
+无状态[容器](/zh-cn/container/)更易于部署，您无需担心如何将容器数据保存在持久存储卷上。
+您也不必担心备份数据。
diff --git a/content/zh-cn/tightly-coupled-architectures.md b/content/zh-cn/tightly-coupled-architectures.md
index 8ba2ba781e..55decc8e14 100644
--- a/content/zh-cn/tightly-coupled-architectures.md
+++ b/content/zh-cn/tightly-coupled-architectures.md
@@ -12,6 +12,7 @@ tags: ["基本原理", "", ""]
 但会使系统更容易受到级联故障的影响。 
 它还意味着需要协调各个组件的部署， 
 这可能会拖累开发人员的生产力。 
+
 紧耦合应用程序架构是一种相当传统的应用程序构建方式。 
 在某些特定情况下，当我们不需要与[微服务](/zh-cn/microservices/) 开发的所有最佳实践一致时，它将变得很有用。
 这意味着更快、更简单地实现， 
diff --git a/content/zh-cn/transport-layer-security.md b/content/zh-cn/transport-layer-security.md
new file mode 100644
index 0000000000..fa4a7903f1
--- /dev/null
+++ b/content/zh-cn/transport-layer-security.md
@@ -0,0 +1,18 @@
+---
+title: 传输层安全性协议（TLS)
+status: Completed
+category: 概念
+tags: ["安全", "", ""]
+---
+
+## 是什么
+
+传输层安全性协议 (TLS) 是一种旨在为网络通信提供更高安全性的协议。它确保通过因特网发送的数据安全交付，避免可能的数据监视和/或篡改。该协议广泛用于消息传递、电子邮件等应用程序中。
+
+## 解决的问题
+
+如果没有 TLS，网页浏览习惯、电子邮件通信、在线聊天和电话会议等敏感信息在传输过程中很容易被他人追踪和篡改。启用服务器和客户端应用程序对 TLS 的支持，可以确保它们之间传输的数据是加密的，并且第三方无法查看。
+
+## 如何帮助
+
+TLS 使用多种编码技术，在通过网络传输数据时提供安全性。 TLS 允许客户端应用程序和服务器（如浏览器和银行站点）之间的加密连接。它还允许客户端应用程序积极地识别他们正在调用的服务器，从而降低客户端与欺诈站点通信的风险。这可以确保第三方无法查看和监控使用 TLS 在应用程序之间传输的数据，从而保护敏感隐私的信息，例如信用卡号、密码、位置等。
diff --git a/content/zh-cn/vertical-scaling.md b/content/zh-cn/vertical-scaling.md
index 72454a008e..f5bfec3a2c 100644
--- a/content/zh-cn/vertical-scaling.md
+++ b/content/zh-cn/vertical-scaling.md
@@ -7,7 +7,7 @@ tags: ["基础设施", "", ""]
 
 ## 是什么
 
-垂直伸缩，也称为“向上和向下伸缩”，是一种通过在工作负载增加时向单个[节点](/nodes/)添加CPU和内存来增加系统容量的技术。
+垂直伸缩，也称为“向上和向下伸缩”，是一种通过在工作负载增加时向单个[节点](/zh-cn/nodes/)添加CPU和内存来增加系统容量的技术。
 假设您有一台 4GB RAM 的计算机，并且想要将其容量增加到 16GB RAM，垂直伸缩就意味着切换到 16GB RAM 系统。
 （请参阅[水平伸缩](/zh-cn/horizontal-scaling/)了解不同的伸缩方法。）
 
diff --git a/content/zh-cn/virtual-machine.md b/content/zh-cn/virtual-machine.md
index b32181006f..eddd48a498 100644
--- a/content/zh-cn/virtual-machine.md
+++ b/content/zh-cn/virtual-machine.md
@@ -14,7 +14,7 @@ tags: ["基本原理", "基础设施", ""]
 ## 解决的问题
 
 虚拟机利用了虚拟化的优势。
-当 [裸机](/bare-metal-machine/) 机器被束缚在一个单一的操作系统上时，该机器的资源的使用受到一定的限制。
+当 [裸机](/zh-cn/bare-metal-machine/) 机器被束缚在一个单一的操作系统上时，该机器的资源的使用受到一定的限制。
 另外，当一个操作系统被绑定在一个单一的物理机上时，它的可用性直接与该硬件联系在一起。
 如果物理机由于维护或硬件故障而脱机，操作系统也会脱机。
 
diff --git a/i18n/de.toml b/i18n/de.toml
new file mode 100644
index 0000000000..d7a2c203e0
--- /dev/null
+++ b/i18n/de.toml
@@ -0,0 +1,71 @@
+
+
+# UI strings. Buttons and similar.
+
+[ui_pager_prev]
+other = "Zurück"
+
+[ui_pager_next]
+other = "Weiter"
+
+[ui_read_more]
+other = "Weiter lesen"
+
+[ui_search]
+other = "Diese Seite durchsuchen ..."
+
+# Used in sentences such as "Posted in News"
+[ui_in]
+other = "in"
+
+# Used in sentences such as "All Tags"
+[ui_all]
+other = "alle"
+
+# Footer text
+[footer_all_rights_reserved]
+other = "Alle Rechte vorbehalten"
+
+[footer_privacy_policy]
+other = "Datenschutzerklärung"
+
+
+# Post (blog, articles etc.)
+[post_byline_by]
+other = "Von"
+[post_created]
+other = "Erstellt"
+[post_last_mod]
+other = "Letzte Änderung"
+[post_edit_this]
+other = "Diese Seite anpassen"
+[post_create_child_page]
+other = "Untergeordnete Seite erstellen"
+[post_create_issue]
+other = "Problem melden"
+[post_create_project_issue]
+other = "Problem bzgl. Projekt melden"
+[post_posts_in]
+other = "Beiträge in"
+[post_reading_time]
+other = "minute read"
+
+# Print support
+[print_printable_section]
+other = "Dies ist die mehrseitige druckbare Ansicht dieses Abschnitts."
+[print_click_to_print]
+other = "Hier klicken zum Drucken"
+[print_show_regular]
+other = "Zurück zur normalen Ansicht dieser Seite"
+[print_entire_section]
+other = "Gesamten Abschnitt drucken"
+
+# Feedback section
+[feedback_title]
+other = "Feedback"
+[feedback_question]
+other = "War diese Seite hilfreich?"
+[feedback_answer_yes]
+other = "Ja"
+[feedback_answer_no]
+other = "Nein"
\ No newline at end of file
diff --git a/layouts/_default/baseof.html b/layouts/_default/baseof.html
index 941ac11388..63711ab6c6 100644
--- a/layouts/_default/baseof.html
+++ b/layouts/_default/baseof.html
@@ -19,7 +19,6 @@
           <main class="col-12 col-md-9 col-xl-7 pl-md-5" role="main">
             {{ partial "version-banner.html" . }}
             {{ if not .Site.Params.ui.breadcrumb_disable }}{{ partial "breadcrumb.html" . }}{{ end }}
-            {{ with .Params.Category}}<div class="category"><i class="{{ lower . }}"></i>{{ upper . }}</div>{{ end }}
             {{ block "main" . }}{{ end }}
           </main>
         </div>
diff --git a/layouts/partials/head.html b/layouts/partials/head.html
index 010392bfaa..ae240e3599 100644
--- a/layouts/partials/head.html
+++ b/layouts/partials/head.html
@@ -53,4 +53,16 @@
 {{ else }}
 {{ template "_internal/google_analytics_async.html" . }}
 {{ end }}
+
+<!-- also include GA4 property -->
+<!-- Google tag (gtag.js) -->
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-T6VMPWFRDW"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-T6VMPWFRDW');
+</script>
+
 {{ end }}
diff --git a/static/images/homepage/kubecon.jpg b/static/images/homepage/kubecon.jpg
new file mode 100644
index 0000000000..b7a854b70c
Binary files /dev/null and b/static/images/homepage/kubecon.jpg differ
diff --git a/wordlist.txt b/wordlist.txt
index fb7cdbe619..4e99359d9a 100644
--- a/wordlist.txt
+++ b/wordlist.txt
@@ -112,6 +112,7 @@ keys
 kubernetes
 lang
 lifecycle
+lifecycles
 linters
 localization
 localizations