fix: bcrypt open source link

Co-authored-by: kamranahmedse <4921183+kamranahmedse@users.noreply.github.com>

.astro/settings.json

@@ -3,6 +3,6 @@
 		"enabled": false
 	},
 	"_variables": {
-		"lastUpdateCheck": 1719080230711
+		"lastUpdateCheck": 1727095669945
 	}
 }

.astro/types.d.ts

@@ -0,0 +1 @@
+/// <reference types="astro/client" />

.github/ISSUE_TEMPLATE/05-project-contribution.yml

@@ -0,0 +1,35 @@
+name: "🙏 ​ ​Submit a Project Idea"
+description: Help us add project ideas to roadmaps.
+labels: [project contribution]
+assignees: []
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to submit a project idea! Please fill out the information below and we'll get back to you as soon as we can.
+  - type: input
+    id: roadmap-title
+    attributes:
+      label: What Roadmap is this project for?
+      placeholder: e.g. Backend Roadmap
+    validations:
+      required: true
+  - type: dropdown
+    id: project-difficulty
+    attributes:
+      label: Project Difficulty
+      options:
+        - Beginner
+        - Intermediate
+        - Advanced
+    validations:
+      required: true
+  - type: textarea
+    id: roadmap-description
+    attributes:
+      label: Add Project Details
+      description: Please write a detailed description of the project in 3rd person e.g. "You are required to build a..."
+      placeholder: |
+          e.g. You are required to build a RESTful API...
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1,14 +1,14 @@
 blank_issues_enabled: false
 contact_links:
   - name: ✋ ​ ​Roadmap Request
-    url: https://discord.gg/cJpEt5Qbwa
+    url: https://roadmap.sh/discord
     about: Please do not open issues with roadmap requests, hop onto the discord server for that.
   - name: 📝 ​ ​Typo or Grammatical Mistake
     url: https://github.com/kamranahmedse/developer-roadmap/tree/master/src/data
     about: Please submit a pull request instead of reporting it as an issue.
   - name: 💬 ​ ​Chat on Discord
-    url: https://discord.gg/cJpEt5Qbwa
+    url: https://roadmap.sh/discord
     about: Join the community on our Discord server.
   - name: 🤝 ​ ​Guidance
-    url: https://discord.gg/cJpEt5Qbwa
+    url: https://roadmap.sh/discord
     about: Join the community in our Discord server.

.github/workflows/cloudfront-api-cache.yml

@@ -0,0 +1,16 @@
+name: Clears API Cloudfront Cache
+on:
+  workflow_dispatch:
+jobs:
+  aws_costs:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clear Cloudfront Caching
+        run: |
+          curl -L \
+            -X POST \
+            -H "Accept: application/vnd.github+json" \
+            -H "Authorization: Bearer ${{ secrets.GH_PAT }}" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            https://api.github.com/repos/roadmapsh/infra-ansible/actions/workflows/playbook.yml/dispatches \
+            -d '{ "ref":"master", "inputs": { "playbook": "roadmap_web.yml", "tags": "cloudfront-api", "is_verbose": false } }'

.github/workflows/cloudfront-cache.yml

@@ -1,16 +0,0 @@
-name: Clears Cloudfront Cache
-on:
-  workflow_dispatch:
-jobs:
-  aws_costs:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Clear Cloudfront Caching
-        run: |
-          curl -L \
-            -X POST \
-            -H "Accept: application/vnd.github+json" \
-            -H "Authorization: Bearer ${{ secrets.GH_PAT }}" \
-            -H "X-GitHub-Api-Version: 2022-11-28" \
-            https://api.github.com/repos/roadmapsh/infra-ansible/actions/workflows/playbook.yml/dispatches \
-            -d '{ "ref":"master", "inputs": { "playbook": "roadmap_web.yml", "tags": "cloudfront", "is_verbose": false } }'

.github/workflows/cloudfront-fe-cache.yml

@@ -0,0 +1,16 @@
+name: Clears Frontend Cloudfront Cache
+on:
+  workflow_dispatch:
+jobs:
+  aws_costs:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clear Cloudfront Caching
+        run: |
+          curl -L \
+            -X POST \
+            -H "Accept: application/vnd.github+json" \
+            -H "Authorization: Bearer ${{ secrets.GH_PAT }}" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            https://api.github.com/repos/roadmapsh/infra-ansible/actions/workflows/playbook.yml/dispatches \
+            -d '{ "ref":"master", "inputs": { "playbook": "roadmap_web.yml", "tags": "cloudfront", "is_verbose": false } }'

.github/workflows/deployment.yml

@@ -1,24 +1,26 @@
 name: Deploy to EC2
+
 on:
-  workflow_dispatch: # allow manual run
+  workflow_dispatch:
+
 jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
+      - name: Checkout Repository
+        uses: actions/checkout@v4
         with:
           fetch-depth: 2
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v4
         with:
           node-version: 20
-      - uses: pnpm/action-setup@v3.0.0
+      - uses: pnpm/action-setup@v4.0.0
         with:
-          version: 8.15.6
+          version: 9
 
-      # --------------------
+      # -------------------
       # Setup configuration
-      # --------------------
+      # -------------------
       - name: Prepare configuration files
         run: |
           git clone https://${{ secrets.GH_PAT }}@github.com/roadmapsh/infra-config.git configuration --depth 1
@@ -26,13 +28,14 @@ jobs:
         run: |
           cp configuration/dist/github/developer-roadmap.env .env
 
-      # --------------------
-      # Prepare the build
-      # --------------------
-      - name: Install dependencies
+      # -----------------
+      # Prepare the Build
+      # -----------------
+      - name: Install Dependencies
         run: |
           pnpm install
-      - name: Generate build
+
+      - name: Generate Production Build
         run: |
           git clone https://${{ secrets.GH_PAT }}@github.com/roadmapsh/web-draw.git .temp/web-draw --depth 1
           npm run generate-renderer
@@ -45,7 +48,7 @@ jobs:
       - uses: webfactory/ssh-agent@v0.7.0
         with:
           ssh-private-key: ${{ secrets.EC2_PRIVATE_KEY }}
-      - name: Deploy app to EC2
+      - name: Deploy Application to EC2
         run: |
           rsync -apvz --delete --no-times --exclude "configuration" -e "ssh -o StrictHostKeyChecking=no" -p ./ ${{ secrets.EC2_USERNAME }}@${{ secrets.EC2_HOST }}:/var/www/roadmap.sh/
       - name: Restart PM2
@@ -58,9 +61,9 @@ jobs:
             cd /var/www/roadmap.sh
             sudo pm2 restart web-roadmap
 
-      # --------------------
+      # ----------------------
       # Clear cloudfront cache
-      # --------------------
+      # ----------------------
       - name: Clear Cloudfront Caching
         run: |
           curl -L \

.github/workflows/label-issue.yml

@@ -1,13 +1,15 @@
 name: Label Issue
+
 on:
   issues:
     types: [ opened, edited ]
+  
 jobs:
   label-topic-change-issue:
     runs-on: ubuntu-latest
     steps:
-      - name: Add roadmap slug to issue as label
-        uses: actions/github-script@v3
+      - name: Add Labels To Issue
+        uses: actions/github-script@v7
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
@@ -18,7 +20,7 @@ jobs:
             if (issue.labels.some(label => label.name === 'topic-change')) {
               if (roadmapUrl) {
                 const roadmapSlug = new URL(roadmapUrl[0]).pathname.replace(/\//, '');
-                github.issues.addLabels({
+                github.rest.issues.addLabels({
                   owner: context.repo.owner,
                   repo: context.repo.repo,
                   issue_number: issue.number,
@@ -28,7 +30,7 @@ jobs:
             
               // Close the issue if it has no roadmap URL
               if (!roadmapUrl) {
-                github.issues.update({
+                github.rest.issues.update({
                   owner: context.repo.owner,
                   repo: context.repo.repo,
                   issue_number: issue.number,

.github/workflows/refresh-roadmap-content-json.yml

@@ -0,0 +1,52 @@
+name: Refresh Roadmap Content JSON
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 0 * * *'
+
+jobs:
+  refresh-content:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup pnpm@v9
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+          run_install: false
+
+      - name: Setup Node.js Version 20 (LTS)
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: 'pnpm'
+
+      - name: Install Dependencies and Generate Content JSON
+        run: |
+          pnpm install
+          npm run generate:roadmap-content-json
+      
+      - name: Create PR
+        uses: peter-evans/create-pull-request@v7
+        with:
+          delete-branch: false
+          branch: "chore/update-content-json"
+          base: "master"
+          labels: |
+            dependencies
+            automated pr
+          reviewers: kamranahmedse
+          commit-message: "chore: update roadmap content json"
+          title: "Updated Roadmap Content JSON - Automated"
+          body: |
+            ## Updated Roadmap Content JSON
+            
+            > [!IMPORTANT]
+            > This PR Updates the Roadmap Content JSON files stored in the `public` directory.
+            >
+            > Commit: ${{ github.sha }}
+            > Workflow Path: ${{ github.workflow_ref }}
+
+            **Please Review the Changes and Merge the PR if everything is fine.**

.github/workflows/update-deps.yml

@@ -1,38 +0,0 @@
-name: Update dependencies
-
-on:
-  workflow_dispatch: # allow manual run
-  schedule:
-    - cron: '0 0 * * 0' # every sunday at midnight
-
-jobs:
-  upgrade-deps:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
-      - uses: pnpm/action-setup@v2.2.2
-        with:
-          version: 7.13.4
-      - name: Upgrade dependencies
-        run: |
-          pnpm install
-          npm run upgrade
-          pnpm install --lockfile-only
-      - name: Create PR
-        uses: peter-evans/create-pull-request@v4
-        with:
-          delete-branch: false
-          branch: "update-deps"
-          base: "master"
-          labels: |
-            dependencies
-            automated pr
-          reviewers: kamranahmedse
-          commit-message: "chore: update dependencies to latest"
-          title: "Upgrade dependencies to latest"
-          body: |
-            Updates all dependencies to latest versions.
-            Please review the changes and merge if everything looks good.

.github/workflows/upgrade-dependencies.yml

@@ -0,0 +1,51 @@
+name: Upgrade Dependencies
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 0 * * 0'
+
+jobs:
+  upgrade-deps:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js Version 20 (LTS)
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Setup pnpm@v9
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+
+      - name: Install & Upgrade Dependencies
+        run: |
+          pnpm install
+          npm run upgrade
+          pnpm install --lockfile-only
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v7
+        with:
+          delete-branch: false
+          branch: "update-deps"
+          base: "master"
+          labels: |
+            dependencies
+            automated pr
+          reviewers: kamranahmedse
+          commit-message: "chore: update dependencies to latest"
+          title: "Upgrade Dependencies To Latest - Automated"
+          body: |
+            ## Updated all Dependencies to Latest Versions.
+
+            > [!IMPORTANT]
+            > This PR Upgrades the Dependencies to the Latest Their Versions.
+            >
+            > Commit: ${{ github.sha }}
+            > Workflow Path: ${{ github.workflow_ref }}
+
+            **Please Review the Changes and Merge the PR if everything is fine.**

astro.config.mjs

@@ -11,9 +11,6 @@ import react from '@astrojs/react';
 // https://astro.build/config
 export default defineConfig({
   site: 'https://roadmap.sh/',
-  experimental: {
-    rewriting: true,
-  },
   markdown: {
     shikiConfig: {
       theme: 'dracula',

contributing.md

@@ -1,12 +1,68 @@
 # Contribution
 
-First of all thank you for considering to contribute. Please look at the details below:
+First of all, thank you for considering to contribute. Please look at the details below:
 
+- [Hacktoberfest Contributions](#hacktoberfest-contributions)
 - [New Roadmaps](#new-roadmaps)
 - [Existing Roadmaps](#existing-roadmaps)
+- [Adding Projects](#adding-projects)
 - [Adding Content](#adding-content)
 - [Guidelines](#guidelines)
 
+## Hacktoberfest Contributions
+
+We are taking part in [Hacktoberfest 11](https://hacktoberfest.com/)!
+
+Before you start to contribute to our project in order to satisfy [Hacktoberfest requirements](https://hacktoberfest.com/participation/#contributors), please bare in mind the following:
+
+* There is not a Hacktoberfest t-shirt this year [(see their FAQ)](https://hacktoberfest.com/participation/#faq).
+* There is not an infinite opportunity to contribute to the roadmap.sh project.
+
+### Hacktoberfest Specific Contribution rules
+
+As Hacktoberfest attracts a lot of contributors (which is awesome), it does require a more rigid and strictly enforced set of guidelines than the average contribution.
+
+These are as follows:
+
+1. No single file contributions, please contribute to a minimum of two.
+
+Whilst single file contributions, such as adding one link to a single topic, is perfectly fine outside of hacktoberfest, this can (and probably will) result it an easy 4 pull requests for everyone and we will just become a Hacktoberfest farming project.
+
+***Note: If you contribute the entire contents of a topic i.e. the topic has 0 copy and 0 links, this will count.***
+
+2. Typo fixes will not count (by themselves).
+
+Whilst fixing typos is a great thing to do, lets bundle them in with actual contributions if we see them!
+
+3. The same basic rules apply.
+
+- Content must be in English.
+- Maximum of 8 links per topic.
+- Follow the below style guide for content.
+
+Here is an example of a **fully complete** topic:
+
+```markdown
+# Redis
+
+Redis is an open-source, in-memory data structure store known for its speed and versatility. It supports various data types, including strings, lists, sets, hashes, and sorted sets, and provides functionalities such as caching, session management, real-time analytics, and message brokering. Redis operates as a key-value store, allowing for rapid read and write operations, and is often used to enhance performance and scalability in applications. It supports persistence options to save data to disk, replication for high availability, and clustering for horizontal scaling. Redis is widely used for scenarios requiring low-latency access to data and high-throughput performance.
+
+Learn more from the following resources:
+
+[@official@Link 1](https:/google.com)
+[@article@Link 2](https:/google.com)
+[@article@Link 3](https:/google.com)
+[@course@Link 4](https:/google.com)
+[@course@Link 5](https:/google.com)
+[@video@Link 6](https:/google.com)
+[@video@Link 7](https:/google.com)
+[@video@Link 8](https:/google.com)
+```
+
+Contributions to the project that meet these requirements will be given the label `hacktoberfest-accepted` and merged, contributions that do not meet the requirements will simply be closed.
+
+Any attempts at spam PRs will be given the `spam` tag. If you recieve 2 `spam` tags against you, you will be [disqualified from Hacktoberfest](https://hacktoberfest.com/participation/#spam).
+
 ## New Roadmaps
 
 For new roadmaps, you can either:
@@ -22,6 +78,28 @@ For the existing roadmaps, please follow the details listed for the nature of co
 
 **Note:** Please note that our goal is <strong>not to have the biggest list of items</strong>. Our goal is to list items or skills most relevant today.
 
+## Adding Projects
+
+If you have a project idea that you think we should add to the roadmap, feel free to open an issue with as many details about the project as possible and the roadmap you think it should be added to.
+
+The detailed format for the issue should be as follows:
+
+```
+## What is this project about?
+
+(Add an introduction to the project.)
+
+## Skills this Project Covers
+
+(Comma separated list of skills, e.g. Programming Knowledge, Database, etc.)
+
+## Requirements
+
+( Detailed list of requirements, i.e. input, output, hints to help build this, etc.)
+```
+
+Have a look at this project to get an idea of [what we are looking for](https://roadmap.sh/projects/github-user-activity).
+
 ## Adding Content
 
 Find [the content directory inside the relevant roadmap](https://github.com/kamranahmedse/developer-roadmap/tree/master/src/data/roadmaps). Please keep the following guidelines in mind when submitting content:
@@ -44,13 +122,12 @@ Visit the following resources to learn more:
 - [@type@Description of link](Link)
 ```
 
-`@type@` must be one of the following and describes the type of content you are adding:
+`@type@` must be one of the following and describe the type of content you are adding:
 
 - `@official@`
 - `@opensource@`
 - `@article@`
 - `@course@`
-- `@opensource@`
 - `@podcast@`
 - `@video@`
 
@@ -58,9 +135,13 @@ It's important to add a valid type, this will help us categorize the content and
 
 ## Guidelines
 
+- <p><strong>Please don't use the project for self-promotion!</strong><br />
+
+  We believe this project is a valuable asset to the developer community, and it includes numerous helpful resources. We kindly ask you to avoid submitting pull requests for the sole purpose of self-promotion. We appreciate contributions that genuinely add value, such as guides from maintainers of well-known frameworks, and will consider accepting these even if they're self authored. Thank you for your understanding and cooperation!
+
 - <p><strong>Adding everything available out there is not the goal!</strong><br />
 
-  The roadmaps represent the skillset most valuable today, i.e., if you were to enter any of the listed fields today, what would you learn? There might be things that are of-course being used today but prioritize the things that are most in demand today, e.g., agreed that lots of people are using angular.js today but you wouldn't want to learn that instead of React, Angular, or Vue. Use your critical thinking to filter out non-essential stuff. Give honest arguments for why the resource should be included.</p>
+  The roadmaps represent the skillset most valuable today, i.e., if you were to enter any of the listed fields today, what would you learn? There might be things that are of-course being used today, but prioritize the things that are most in demand today, e.g., agree that lots of people are using angular.js today, but you wouldn't want to learn that instead of React, Angular, or Vue. Use your critical thinking to filter out non-essential stuff. Give honest arguments for why the resource should be included.</p>
 
 - <p><strong>Do not add things you have not evaluated personally!</strong><br />
 
@@ -72,14 +153,12 @@ It's important to add a valid type, this will help us categorize the content and
 
 - <p><strong>Write meaningful commit messages</strong><br >
 
-  Meaningful commit messages help speed up the review process as well as help other contributors in gaining a good overview of the repositories commit history without having to dive into every commit.
-  
-  (See the following guide on how to write good [commit messages](https://www.freecodecamp.org/news/how-to-write-better-git-commit-messages/)).
+  Meaningful commit messages help speed up the review process as well as help other contributors gain a good overview of the repositories commit history without having to dive into every commit.
 
   </p>
 - <p><strong>Look at the existing issues/pull requests before opening new ones</strong></p>
 
-### Good vs Not So Good Contributions
+### Good vs. Not So Good Contributions
 
 <strong>Good</strong>
 
@@ -92,5 +171,6 @@ It's important to add a valid type, this will help us categorize the content and
 
   - Adding whitespace that doesn't add to the readability of the content.
   - Rewriting content in a way that doesn't add any value.
-  - None English content.
-  - PR's that don't follow our style guide, have no description and a default title.
+  - Non-English content.
+  - PR's that don't follow our style guide, have no description, and a default title.
+  - Links to your own blog articles.

package.json

@@ -25,69 +25,75 @@
     "generate:og": "node ./scripts/generate-og-images.mjs",
     "warm:urls": "sh ./scripts/warm-urls.sh https://roadmap.sh/sitemap-0.xml",
     "compress:images": "tsx ./scripts/compress-images.ts",
+    "generate:roadmap-content-json": "tsx ./scripts/editor-roadmap-content-json.ts",
     "test:e2e": "playwright test"
   },
   "dependencies": {
-    "@astrojs/node": "^8.2.5",
-    "@astrojs/react": "^3.4.0",
-    "@astrojs/sitemap": "^3.1.5",
+    "@astrojs/node": "^8.3.3",
+    "@astrojs/react": "^3.6.2",
+    "@astrojs/sitemap": "^3.1.6",
     "@astrojs/tailwind": "^5.1.0",
-    "@fingerprintjs/fingerprintjs": "^4.3.0",
+    "@fingerprintjs/fingerprintjs": "^4.4.3",
     "@nanostores/react": "^0.7.2",
     "@napi-rs/image": "^1.9.2",
     "@resvg/resvg-js": "^2.6.2",
-    "@types/react": "^18.3.2",
+    "@types/react": "^18.3.3",
     "@types/react-dom": "^18.3.0",
-    "astro": "^4.9.1",
+    "astro": "^4.15.4",
     "clsx": "^2.1.1",
-    "dayjs": "^1.11.11",
+    "dayjs": "^1.11.12",
     "dom-to-image": "^2.6.0",
     "dracula-prism": "^2.1.16",
     "gray-matter": "^4.0.3",
     "htm": "^3.1.1",
     "image-size": "^1.1.1",
-    "jose": "^5.3.0",
+    "jose": "^5.6.3",
     "js-cookie": "^3.0.5",
-    "lucide-react": "^0.378.0",
+    "lucide-react": "^0.419.0",
+    "luxon": "^3.5.0",
     "nanoid": "^5.0.7",
     "nanostores": "^0.10.3",
     "node-html-parser": "^6.1.13",
-    "npm-check-updates": "^16.14.20",
-    "playwright": "^1.44.0",
+    "npm-check-updates": "^17.0.0",
+    "playwright": "^1.47.1",
     "prismjs": "^1.29.0",
     "react": "^18.3.1",
     "react-calendar-heatmap": "^1.9.0",
     "react-confetti": "^6.1.0",
     "react-dom": "^18.3.1",
-    "react-tooltip": "^5.26.4",
-    "reactflow": "^11.11.3",
+    "react-tooltip": "^5.27.1",
+    "reactflow": "^11.11.4",
     "rehype-external-links": "^3.0.0",
     "remark-parse": "^11.0.0",
     "roadmap-renderer": "^1.0.6",
-    "satori": "^0.10.13",
+    "satori": "^0.10.14",
     "satori-html": "^0.3.2",
     "sharp": "^0.33.4",
     "slugify": "^1.6.6",
-    "tailwind-merge": "^2.3.0",
-    "tailwindcss": "^3.4.3",
-    "unified": "^11.0.4",
-    "zustand": "^4.5.2"
+    "tailwind-merge": "^2.4.0",
+    "tailwindcss": "^3.4.7",
+    "turndown": "^7.2.0",
+    "unified": "^11.0.5",
+    "zustand": "^4.5.4"
   },
   "devDependencies": {
-    "@playwright/test": "^1.44.0",
+    "@playwright/test": "^1.45.3",
     "@tailwindcss/typography": "^0.5.13",
     "@types/dom-to-image": "^2.6.7",
     "@types/js-cookie": "^3.0.6",
+    "@types/luxon": "^3.4.2",
     "@types/prismjs": "^1.26.4",
     "@types/react-calendar-heatmap": "^1.6.7",
+    "@types/react-slick": "^0.23.13",
+    "@types/turndown": "^5.0.5",
     "csv-parser": "^3.0.0",
     "gh-pages": "^6.1.1",
     "js-yaml": "^4.1.0",
     "markdown-it": "^14.1.0",
-    "openai": "^4.47.1",
-    "prettier": "^3.2.5",
-    "prettier-plugin-astro": "^0.13.0",
-    "prettier-plugin-tailwindcss": "^0.5.14",
-    "tsx": "^4.10.5"
+    "openai": "^4.53.2",
+    "prettier": "^3.3.3",
+    "prettier-plugin-astro": "^0.14.1",
+    "prettier-plugin-tailwindcss": "^0.6.5",
+    "tsx": "^4.16.5"
   }
 }

public/roadmap-content/ai-data-scientist.json

@@ -0,0 +1,420 @@
+{
+  "aStaDENn5PhEa-cFvNzXa": {
+    "title": "Mathematics",
+    "description": "Mathematics is the foundation of AI and Data Science. It is essential to have a good understanding of mathematics to excel in these fields.",
+    "links": [
+      {
+        "title": "Mathematics for Machine Learning",
+        "url": "https://imp.i384100.net/baqMYv",
+        "type": "article"
+      },
+      {
+        "title": "Algebra and Differential Calculus",
+        "url": "https://imp.i384100.net/LX5M7M",
+        "type": "article"
+      }
+    ]
+  },
+  "4WZL_fzJ3cZdWLLDoWN8D": {
+    "title": "Statistics",
+    "description": "Statistics is the science of collecting, analyzing, interpreting, presenting, and organizing data. It is a branch of mathematics that deals with the collection, analysis, interpretation, presentation, and organization of data. It is used in a wide range of fields, including science, engineering, medicine, and social science. Statistics is used to make informed decisions, to predict future events, and to test hypotheses. It is also used to summarize data, to describe relationships between variables, and to make inferences about populations based on samples.\n\nLearn more from the resources given on the roadmap.",
+    "links": []
+  },
+  "gWMvD83hVXeTmCuHGIiOL": {
+    "title": "Linear Algebra, Calculus, Mathematical Analysis",
+    "description": "",
+    "links": [
+      {
+        "title": "Mathematics for Machine Learning Specialization",
+        "url": "https://imp.i384100.net/baqMYv",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Math",
+        "url": "https://app.daily.dev/tags/math?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Linear Algebra Youtube Course",
+        "url": "https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab",
+        "type": "video"
+      }
+    ]
+  },
+  "mwPJh33MEUQ4Co_LiVEOb": {
+    "title": "Differential Calculus",
+    "description": "",
+    "links": [
+      {
+        "title": "Algebra and Differential Calculus for Data Science",
+        "url": "https://imp.i384100.net/LX5M7M",
+        "type": "article"
+      }
+    ]
+  },
+  "Y9YJdARIRqqCBCy3GVYdA": {
+    "title": "Statistics, CLT",
+    "description": "",
+    "links": [
+      {
+        "title": "Introduction to Statistics",
+        "url": "https://imp.i384100.net/3eRv4v",
+        "type": "article"
+      }
+    ]
+  },
+  "XJXIkWVDIrPJ-bVIvX0ZO": {
+    "title": "Hypothesis Testing",
+    "description": "",
+    "links": [
+      {
+        "title": "Introduction to Statistical Analysis: Hypothesis Testing",
+        "url": "https://imp.i384100.net/vN0JAA",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Testing",
+        "url": "https://app.daily.dev/tags/testing?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "jxJtwbiCvxHqmkWkE7zdx": {
+    "title": "Probability and Sampling",
+    "description": "",
+    "links": [
+      {
+        "title": "Probability and Statistics: To p or not to p?",
+        "url": "https://imp.i384100.net/daDM6Q",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Statistics",
+        "url": "https://app.daily.dev/tags/statistics?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "mJq9b50MJM9o9dLhx40iN": {
+    "title": "AB Testing",
+    "description": "",
+    "links": [
+      {
+        "title": "Practitioner’s Guide to Statistical Tests",
+        "url": "https://vkteam.medium.com/practitioners-guide-to-statistical-tests-ed2d580ef04f#1e3b",
+        "type": "article"
+      },
+      {
+        "title": "Step by Step Process for Planning an A/B Test",
+        "url": "https://towardsdatascience.com/step-by-step-for-planning-an-a-b-test-ef3c93143c0b",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about A/B Testing",
+        "url": "https://app.daily.dev/tags/ab-testing?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "v68nwX914qCwHDSwY_ZhG": {
+    "title": "Increasing Test Sensitivity",
+    "description": "",
+    "links": [
+      {
+        "title": "Minimum Detectable Effect (MDE)",
+        "url": "https://splitmetrics.com/resources/minimum-detectable-effect-mde/",
+        "type": "article"
+      },
+      {
+        "title": "Improving the Sensitivity of Online Controlled Experiments: Case Studies at Netflix",
+        "url": "https://kdd.org/kdd2016/papers/files/adp0945-xieA.pdf",
+        "type": "article"
+      },
+      {
+        "title": "Improving the Sensitivity of Online Controlled Experiments by Utilizing Pre-Experiment Data",
+        "url": "https://exp-platform.com/Documents/2013-02-CUPED-ImprovingSensitivityOfControlledExperiments.pdf",
+        "type": "article"
+      },
+      {
+        "title": "How Booking.com increases the power of online experiments with CUPED",
+        "url": "https://booking.ai/how-booking-com-increases-the-power-of-online-experiments-with-cuped-995d186fff1d",
+        "type": "article"
+      },
+      {
+        "title": "Improving Experimental Power through Control Using Predictions as Covariate — CUPAC",
+        "url": "https://doordash.engineering/2020/06/08/improving-experimental-power-through-control-using-predictions-as-covariate-cupac/",
+        "type": "article"
+      },
+      {
+        "title": "Improving the Sensitivity of Online Controlled Experiments: Case Studies at Netflix",
+        "url": "https://www.researchgate.net/publication/305997925_Improving_the_Sensitivity_of_Online_Controlled_Experiments_Case_Studies_at_Netflix",
+        "type": "article"
+      }
+    ]
+  },
+  "n2JFGwFxTuOviW6kHO1Uv": {
+    "title": "Ratio Metrics",
+    "description": "",
+    "links": [
+      {
+        "title": "Applying the Delta Method in Metric Analytics: A Practical Guide with Novel Ideas",
+        "url": "https://arxiv.org/pdf/1803.06336.pdf",
+        "type": "article"
+      },
+      {
+        "title": "Approximations for Mean and Variance of a Ratio",
+        "url": "https://www.stat.cmu.edu/~hseltman/files/ratio.pdf",
+        "type": "article"
+      }
+    ]
+  },
+  "Gd2egqKZPnbPW1W2jw4j8": {
+    "title": "Econometrics",
+    "description": "Ecenometrics is the application of statistical methods to economic data. It is a branch of economics that aims to give empirical content to economic relations. More precisely, it is \"the quantitative analysis of actual economic phenomena based on the concurrent development of theory and observation, related by appropriate methods of inference.\" Econometrics can be described as something that allows economists \"to sift through mountains of data to extract simple relationships.\"",
+    "links": []
+  },
+  "y6xXsc-uSAmRDnNuyhqH2": {
+    "title": "Pre-requisites of Econometrics",
+    "description": "",
+    "links": [
+      {
+        "title": "10 Fundamental Theorems for Econometrics",
+        "url": "https://bookdown.org/ts_robinson1994/10EconometricTheorems/",
+        "type": "article"
+      }
+    ]
+  },
+  "h19k9Fn5XPh3_pKEC8Ftp": {
+    "title": "Regression, Timeseries, Fitting Distributions",
+    "description": "",
+    "links": [
+      {
+        "title": "Blockchain.com Data Scientist TakeHome Test",
+        "url": "https://github.com/stalkermustang/bcdc_ds_takehome",
+        "type": "opensource"
+      },
+      {
+        "title": "10 Fundamental Theorems for Econometrics",
+        "url": "https://bookdown.org/ts_robinson1994/10EconometricTheorems/",
+        "type": "article"
+      },
+      {
+        "title": "Dougherty Intro to Econometrics 4th edition",
+        "url": "https://www.academia.edu/33062577/Dougherty_Intro_to_Econometrics_4th_ed_small",
+        "type": "article"
+      },
+      {
+        "title": "Econometrics: Methods and Applications",
+        "url": "https://imp.i384100.net/k0krYL",
+        "type": "article"
+      },
+      {
+        "title": "Kaggle - Learn Time Series",
+        "url": "https://www.kaggle.com/learn/time-series",
+        "type": "article"
+      },
+      {
+        "title": "Time series Basics : Exploring traditional TS",
+        "url": "https://www.kaggle.com/code/jagangupta/time-series-basics-exploring-traditional-ts#Hierarchical-time-series",
+        "type": "article"
+      },
+      {
+        "title": "How to Create an ARIMA Model for Time Series Forecasting in Python",
+        "url": "https://machinelearningmastery.com/arima-for-time-series-forecasting-with-python",
+        "type": "article"
+      },
+      {
+        "title": "11 Classical Time Series Forecasting Methods in Python",
+        "url": "https://machinelearningmastery.com/time-series-forecasting-methods-in-python-cheat-sheet/",
+        "type": "article"
+      },
+      {
+        "title": "Linear Regression for Business Statistics",
+        "url": "https://imp.i384100.net/9g97Ke",
+        "type": "article"
+      }
+    ]
+  },
+  "XLDWuSt4tI4gnmqMFdpmy": {
+    "title": "Coding",
+    "description": "Programming is a fundamental skill for data scientists. You need to be able to write code to manipulate data, build models, and deploy solutions. The most common programming languages used in data science are Python and R. Python is a general-purpose programming language that is easy to learn and has a large number of libraries for data manipulation and machine learning. R is a programming language and free software environment for statistical computing and graphics. It is widely used for statistical analysis and data visualization.",
+    "links": []
+  },
+  "MVrAqizgkoAs2aghN8TgV": {
+    "title": "Learn Python Programming Language",
+    "description": "",
+    "links": [
+      {
+        "title": "Kaggle — Python",
+        "url": "https://www.kaggle.com/learn/python",
+        "type": "article"
+      },
+      {
+        "title": "Google's Python Class",
+        "url": "https://developers.google.com/edu/python",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Python",
+        "url": "https://app.daily.dev/tags/python?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "StBCykpzpM4g9PRFeSNXa": {
+    "title": "Data Structures and Algorithms (Python)",
+    "description": "",
+    "links": [
+      {
+        "title": "Learn Algorithms",
+        "url": "https://leetcode.com/explore/learn/",
+        "type": "article"
+      },
+      {
+        "title": "Leetcode - Study Plans",
+        "url": "https://leetcode.com/studyplan/",
+        "type": "article"
+      },
+      {
+        "title": "Algorithms Specialization",
+        "url": "https://imp.i384100.net/5gqv4n",
+        "type": "article"
+      }
+    ]
+  },
+  "Im0tXXn3GC-FUq2aMHgwm": {
+    "title": "Learn SQL",
+    "description": "",
+    "links": [
+      {
+        "title": "SQL Tutorial",
+        "url": "https://www.sqltutorial.org/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about SQL",
+        "url": "https://app.daily.dev/tags/sql?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "l1027SBZxTHKzqWw98Ee-": {
+    "title": "Exploratory Data Analysis",
+    "description": "Exploratory Data Analysis (EDA) is an approach to analyzing data sets to summarize their main characteristics, often with visual methods. EDA is used to understand what the data can tell us beyond the formal modeling or hypothesis testing task. It is a crucial step in the data analysis process.",
+    "links": []
+  },
+  "JaN8YhMeN3whAe2TCXvw9": {
+    "title": "Data understanding, Data Analysis and Visualization",
+    "description": "",
+    "links": [
+      {
+        "title": "Exploratory Data Analysis With Python and Pandas",
+        "url": "https://imp.i384100.net/AWAv4R",
+        "type": "article"
+      },
+      {
+        "title": "Exploratory Data Analysis for Machine Learning",
+        "url": "https://imp.i384100.net/GmQMLE",
+        "type": "article"
+      },
+      {
+        "title": "Exploratory Data Analysis with Seaborn",
+        "url": "https://imp.i384100.net/ZQmMgR",
+        "type": "article"
+      }
+    ]
+  },
+  "kBdt_t2SvVsY3blfubWIz": {
+    "title": "Machine Learning",
+    "description": "Machine learning is a field of artificial intelligence that uses statistical techniques to give computer systems the ability to \"learn\" (e.g., progressively improve performance on a specific task) from data, without being explicitly programmed. The name machine learning was coined in 1959 by Arthur Samuel. Evolved from the study of pattern recognition and computational learning theory in artificial intelligence, machine learning explores the study and construction of algorithms that can learn from and make predictions on data – such algorithms overcome following strictly static program instructions by making data-driven predictions or decisions, through building a model from sample inputs. Machine learning is employed in a range of computing tasks where designing and programming explicit algorithms with good performance is difficult or infeasible; example applications include email filtering, detection of network intruders, and computer vision.",
+    "links": []
+  },
+  "FdBih8tlGPPy97YWq463y": {
+    "title": "Classic ML (Sup., Unsup.), Advanced ML (Ensembles, NNs)",
+    "description": "",
+    "links": [
+      {
+        "title": "Repository of notes, code and notebooks in Python for the book Pattern Recognition and Machine Learning by Christopher Bishop",
+        "url": "https://github.com/gerdm/prml",
+        "type": "opensource"
+      },
+      {
+        "title": "Open Machine Learning Course",
+        "url": "https://mlcourse.ai/book/topic01/topic01_intro.html",
+        "type": "article"
+      },
+      {
+        "title": "Coursera: Machine Learning Specialization",
+        "url": "https://imp.i384100.net/oqGkrg",
+        "type": "article"
+      },
+      {
+        "title": "Pattern Recognition and Machine Learning by Christopher Bishop",
+        "url": "https://www.microsoft.com/en-us/research/uploads/prod/2006/01/Bishop-Pattern-Recognition-and-Machine-Learning-2006.pdf",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Machine Learning",
+        "url": "https://app.daily.dev/tags/machine-learning?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "cjvVLN0XjrKPn6o20oMmc": {
+    "title": "Deep Learning",
+    "description": "Deep Learning\n-------------\n\nDeep learning is a subset of machine learning that deals with algorithms inspired by the structure and function of the brain called artificial neural networks. Deep learning is a key technology behind driverless cars, enabling them to recognize a stop sign, or to distinguish a pedestrian from a lamppost. It is the key to voice control in consumer devices like phones, tablets, TVs, and hands-free speakers. Deep learning is getting lots of attention lately and for good reason. It’s achieving results that were not possible before.",
+    "links": []
+  },
+  "eOFoGKveaHaBm_6ppJUtA": {
+    "title": "Fully Connected, CNN, RNN, LSTM, Transformers, TL",
+    "description": "",
+    "links": [
+      {
+        "title": "The Illustrated Transformer",
+        "url": "https://jalammar.github.io/illustrated-transformer/",
+        "type": "article"
+      },
+      {
+        "title": "Attention is All you Need",
+        "url": "https://arxiv.org/pdf/1706.03762.pdf",
+        "type": "article"
+      },
+      {
+        "title": "Deep Learning Book",
+        "url": "https://www.deeplearningbook.org/",
+        "type": "article"
+      },
+      {
+        "title": "Deep Learning Specialization",
+        "url": "https://imp.i384100.net/Wq9MV3",
+        "type": "article"
+      }
+    ]
+  },
+  "Qa85hEVe2kz62k9Pj4QCA": {
+    "title": "MLOps",
+    "description": "MLOps is a practice for collaboration and communication between data scientists and operations professionals to help manage production ML lifecycle. It is a set of best practices that aims to automate the ML lifecycle, including training, deployment, and monitoring. MLOps helps organizations to scale ML models and deliver business value faster.",
+    "links": []
+  },
+  "uPzzUpI0--7OWDfNeBIjt": {
+    "title": "Deployment Models, CI/CD",
+    "description": "",
+    "links": [
+      {
+        "title": "Machine Learning Engineering for Production (MLOps) Specialization",
+        "url": "https://imp.i384100.net/nLA5mx",
+        "type": "article"
+      },
+      {
+        "title": "Full Stack Deep Learning",
+        "url": "https://fullstackdeeplearning.com/course/2022/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about CI/CD",
+        "url": "https://app.daily.dev/tags/cicd?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  }
+}

public/roadmap-content/ai-engineer.json

@@ -0,0 +1,582 @@
+{
+  "_hYN0gEi9BL24nptEtXWU": {
+    "title": "Introduction",
+    "description": "",
+    "links": []
+  },
+  "GN6SnI7RXIeW8JeD-qORW": {
+    "title": "What is an AI Engineer?",
+    "description": "",
+    "links": []
+  },
+  "jSZ1LhPdhlkW-9QJhIvFs": {
+    "title": "AI Engineer vs ML Engineer",
+    "description": "",
+    "links": []
+  },
+  "wf2BSyUekr1S1q6l8kyq6": {
+    "title": "LLMs",
+    "description": "",
+    "links": []
+  },
+  "KWjD4xEPhOOYS51dvRLd2": {
+    "title": "Inference",
+    "description": "",
+    "links": []
+  },
+  "xostGgoaYkqMO28iN2gx8": {
+    "title": "Training",
+    "description": "",
+    "links": []
+  },
+  "XyEp6jnBSpCxMGwALnYfT": {
+    "title": "Embeddings",
+    "description": "",
+    "links": []
+  },
+  "LnQ2AatMWpExUHcZhDIPd": {
+    "title": "Vector Databases",
+    "description": "",
+    "links": []
+  },
+  "9JwWIK0Z2MK8-6EQQJsCO": {
+    "title": "RAG",
+    "description": "",
+    "links": []
+  },
+  "Dc15ayFlzqMF24RqIF_-X": {
+    "title": "Prompt Engineering",
+    "description": "",
+    "links": []
+  },
+  "9XCxilAQ7FRet7lHQr1gE": {
+    "title": "AI Agents",
+    "description": "",
+    "links": []
+  },
+  "5QdihE1lLpMc3DFrGy46M": {
+    "title": "AI vs AGI",
+    "description": "",
+    "links": []
+  },
+  "qJVgKe9uBvXc-YPfvX_Y7": {
+    "title": "Impact on Product Development",
+    "description": "",
+    "links": []
+  },
+  "K9EiuFgPBFgeRxY4wxAmb": {
+    "title": "Roles and Responsiblities",
+    "description": "",
+    "links": []
+  },
+  "d7fzv_ft12EopsQdmEsel": {
+    "title": "Pre-trained Models",
+    "description": "",
+    "links": []
+  },
+  "1Ga6DbOPc6Crz7ilsZMYy": {
+    "title": "Benefits of Pre-trained Models",
+    "description": "",
+    "links": []
+  },
+  "MXqbQGhNM3xpXlMC2ib_6": {
+    "title": "Limitations and Considerations",
+    "description": "",
+    "links": []
+  },
+  "2WbVpRLqwi3Oeqk1JPui4": {
+    "title": "Open AI Models",
+    "description": "",
+    "links": []
+  },
+  "vvpYkmycH0_W030E-L12f": {
+    "title": "Capabilities / Context Length",
+    "description": "",
+    "links": []
+  },
+  "LbB2PeytxRSuU07Bk0KlJ": {
+    "title": "Cut-off Dates / Knowledge",
+    "description": "",
+    "links": []
+  },
+  "hy6EyKiNxk1x84J63dhez": {
+    "title": "Anthropic's Claude",
+    "description": "",
+    "links": []
+  },
+  "oe8E6ZIQWuYvHVbYJHUc1": {
+    "title": "Google's Gemini",
+    "description": "",
+    "links": []
+  },
+  "3PQVZbcr4neNMRr6CuNzS": {
+    "title": "Azure AI",
+    "description": "",
+    "links": []
+  },
+  "OkYO-aSPiuVYuLXHswBCn": {
+    "title": "AWS Sagemaker",
+    "description": "",
+    "links": []
+  },
+  "8XjkRqHOdyH-DbXHYiBEt": {
+    "title": "Hugging Face Models",
+    "description": "",
+    "links": []
+  },
+  "n-Ud2dXkqIzK37jlKItN4": {
+    "title": "Mistral AI",
+    "description": "",
+    "links": []
+  },
+  "a7qsvoauFe5u953I699ps": {
+    "title": "Cohere",
+    "description": "",
+    "links": []
+  },
+  "5ShWZl1QUqPwO-NRGN85V": {
+    "title": "OpenAI Models",
+    "description": "",
+    "links": []
+  },
+  "zdeuA4GbdBl2DwKgiOA4G": {
+    "title": "OpenAI API",
+    "description": "",
+    "links": []
+  },
+  "_bPTciEA1GT1JwfXim19z": {
+    "title": "Chat Completions API",
+    "description": "",
+    "links": []
+  },
+  "9-5DYeOnKJq9XvEMWP45A": {
+    "title": "Writing Prompts",
+    "description": "",
+    "links": []
+  },
+  "nyBgEHvUhwF-NANMwkRJW": {
+    "title": "Open AI Playground",
+    "description": "",
+    "links": []
+  },
+  "15XOFdVp0IC-kLYPXUJWh": {
+    "title": "Fine-tuning",
+    "description": "",
+    "links": []
+  },
+  "qzvp6YxWDiGakA2mtspfh": {
+    "title": "Maximum Tokens",
+    "description": "",
+    "links": []
+  },
+  "FjV3oD7G2Ocq5HhUC17iH": {
+    "title": "Token Counting",
+    "description": "",
+    "links": []
+  },
+  "DZPM9zjCbYYWBPLmQImxQ": {
+    "title": "Pricing Considerations",
+    "description": "",
+    "links": []
+  },
+  "8ndKHDJgL_gYwaXC7XMer": {
+    "title": "AI Safety and Ethics",
+    "description": "",
+    "links": []
+  },
+  "cUyLT6ctYQ1pgmodCKREq": {
+    "title": "Prompt Injection Attacks",
+    "description": "",
+    "links": []
+  },
+  "lhIU0ulpvDAn1Xc3ooYz_": {
+    "title": "Bias and Fareness",
+    "description": "",
+    "links": []
+  },
+  "sWBT-j2cRuFqRFYtV_5TK": {
+    "title": "Security and Privacy Concerns",
+    "description": "",
+    "links": []
+  },
+  "Pt-AJmSJrOxKvolb5_HEv": {
+    "title": "Conducting adversarial testing",
+    "description": "",
+    "links": []
+  },
+  "ljZLa3yjQpegiZWwtnn_q": {
+    "title": "OpenAI Moderation API",
+    "description": "",
+    "links": []
+  },
+  "4Q5x2VCXedAWISBXUIyin": {
+    "title": "Adding end-user IDs in prompts",
+    "description": "",
+    "links": []
+  },
+  "qmx6OHqx4_0JXVIv8dASp": {
+    "title": "Robust prompt engineering",
+    "description": "",
+    "links": []
+  },
+  "t1SObMWkDZ1cKqNNlcd9L": {
+    "title": "Know your Customers / Usecases",
+    "description": "",
+    "links": []
+  },
+  "ONLDyczNacGVZGojYyJrU": {
+    "title": "Constraining outputs and inputs",
+    "description": "",
+    "links": []
+  },
+  "a_3SabylVqzzOyw3tZN5f": {
+    "title": "OpenSource AI",
+    "description": "",
+    "links": []
+  },
+  "RBwGsq9DngUsl8PrrCbqx": {
+    "title": "Open vs Closed Source Models",
+    "description": "",
+    "links": []
+  },
+  "97eu-XxYUH9pYbD_KjAtA": {
+    "title": "Popular Open Source Models",
+    "description": "",
+    "links": []
+  },
+  "v99C5Bml2a6148LCJ9gy9": {
+    "title": "Hugging Face",
+    "description": "",
+    "links": []
+  },
+  "YLOdOvLXa5Fa7_mmuvKEi": {
+    "title": "Hugging Face Hub",
+    "description": "",
+    "links": []
+  },
+  "YKIPOiSj_FNtg0h8uaSMq": {
+    "title": "Hugging Face Tasks",
+    "description": "",
+    "links": []
+  },
+  "3kRTzlLNBnXdTsAEXVu_M": {
+    "title": "Inference SDK",
+    "description": "",
+    "links": []
+  },
+  "bGLrbpxKgENe2xS1eQtdh": {
+    "title": "Transformers.js",
+    "description": "",
+    "links": []
+  },
+  "rTT2UnvqFO3GH6ThPLEjO": {
+    "title": "Ollama",
+    "description": "",
+    "links": []
+  },
+  "ro3vY_sp6xMQ-hfzO-rc1": {
+    "title": "Ollama Models",
+    "description": "",
+    "links": []
+  },
+  "TsG_I7FL-cOCSw8gvZH3r": {
+    "title": "Ollama SDK",
+    "description": "",
+    "links": []
+  },
+  "--ig0Ume_BnXb9K2U7HJN": {
+    "title": "What are Embeddings",
+    "description": "",
+    "links": []
+  },
+  "eMfcyBxnMY_l_5-8eg6sD": {
+    "title": "Semantic Search",
+    "description": "",
+    "links": []
+  },
+  "HQe9GKy3p0kTUPxojIfSF": {
+    "title": "Recommendation Systems",
+    "description": "",
+    "links": []
+  },
+  "AglWJ7gb9rTT2rMkstxtk": {
+    "title": "Anomaly Detection",
+    "description": "",
+    "links": []
+  },
+  "06Xta-OqSci05nV2QMFdF": {
+    "title": "Data Classification",
+    "description": "",
+    "links": []
+  },
+  "l6priWeJhbdUD5tJ7uHyG": {
+    "title": "Open AI Embeddings API",
+    "description": "",
+    "links": []
+  },
+  "y0qD5Kb4Pf-ymIwW-tvhX": {
+    "title": "Open AI Embedding Models",
+    "description": "",
+    "links": []
+  },
+  "4GArjDYipit4SLqKZAWDf": {
+    "title": "Pricing Considerations",
+    "description": "",
+    "links": []
+  },
+  "apVYIV4EyejPft25oAvdI": {
+    "title": "Open-Source Embeddings",
+    "description": "",
+    "links": []
+  },
+  "ZV_V6sqOnRodgaw4mzokC": {
+    "title": "Sentence Transformers",
+    "description": "",
+    "links": []
+  },
+  "dLEg4IA3F5jgc44Bst9if": {
+    "title": "Models on Hugging Face",
+    "description": "",
+    "links": []
+  },
+  "tt9u3oFlsjEMfPyojuqpc": {
+    "title": "Vector Databases",
+    "description": "",
+    "links": []
+  },
+  "WcjX6p-V-Rdd77EL8Ega9": {
+    "title": "Purpose and Functionality",
+    "description": "",
+    "links": []
+  },
+  "dSd2C9lNl-ymmCRT9_ZC3": {
+    "title": "Chroma",
+    "description": "",
+    "links": []
+  },
+  "_Cf7S1DCvX7p1_3-tP3C3": {
+    "title": "Pinecone",
+    "description": "",
+    "links": []
+  },
+  "VgUnrZGKVjAAO4n_llq5-": {
+    "title": "Weaviate",
+    "description": "",
+    "links": []
+  },
+  "JurLbOO1Z8r6C3yUqRNwf": {
+    "title": "FAISS",
+    "description": "",
+    "links": []
+  },
+  "rjaCNT3Li45kwu2gXckke": {
+    "title": "LanceDB",
+    "description": "",
+    "links": []
+  },
+  "DwOAL5mOBgBiw-EQpAzQl": {
+    "title": "Qdrant",
+    "description": "",
+    "links": []
+  },
+  "9kT7EEQsbeD2WDdN9ADx7": {
+    "title": "Supabase",
+    "description": "",
+    "links": []
+  },
+  "j6bkm0VUgLkHdMDDJFiMC": {
+    "title": "MongoDB Atlas",
+    "description": "",
+    "links": []
+  },
+  "5TQnO9B4_LTHwqjI7iHB1": {
+    "title": "Indexing Embeddings",
+    "description": "",
+    "links": []
+  },
+  "ZcbRPtgaptqKqWBgRrEBU": {
+    "title": "Performing Similarity Search",
+    "description": "",
+    "links": []
+  },
+  "lVhWhZGR558O-ljHobxIi": {
+    "title": "RAG & Implementation",
+    "description": "",
+    "links": []
+  },
+  "GCn4LGNEtPI0NWYAZCRE-": {
+    "title": "RAG Usecases",
+    "description": "",
+    "links": []
+  },
+  "qlBEXrbV88e_wAGRwO9hW": {
+    "title": "RAG vs Fine-tuning",
+    "description": "",
+    "links": []
+  },
+  "mX987wiZF7p3V_gExrPeX": {
+    "title": "Chunking",
+    "description": "",
+    "links": []
+  },
+  "grTcbzT7jKk_sIUwOTZTD": {
+    "title": "Embedding",
+    "description": "",
+    "links": []
+  },
+  "zZA1FBhf1y4kCoUZ-hM4H": {
+    "title": "Vector Database",
+    "description": "",
+    "links": []
+  },
+  "OCGCzHQM2LQyUWmiqe6E0": {
+    "title": "Retrieval Process",
+    "description": "",
+    "links": []
+  },
+  "2jJnS9vRYhaS69d6OxrMh": {
+    "title": "Generation",
+    "description": "",
+    "links": []
+  },
+  "WZVW8FQu6LyspSKm1C_sl": {
+    "title": "Using SDKs Directly",
+    "description": "",
+    "links": []
+  },
+  "ebXXEhNRROjbbof-Gym4p": {
+    "title": "Langchain",
+    "description": "",
+    "links": []
+  },
+  "d0ontCII8KI8wfP-8Y45R": {
+    "title": "Llama Index",
+    "description": "",
+    "links": []
+  },
+  "eOqCBgBTKM8CmY3nsWjre": {
+    "title": "Open AI Assistant API",
+    "description": "",
+    "links": []
+  },
+  "c0RPhpD00VIUgF4HJgN2T": {
+    "title": "Replicate",
+    "description": "",
+    "links": []
+  },
+  "AeHkNU-uJ_gBdo5-xdpEu": {
+    "title": "AI Agents",
+    "description": "",
+    "links": []
+  },
+  "778HsQzTuJ_3c9OSn5DmH": {
+    "title": "Agents Usecases",
+    "description": "",
+    "links": []
+  },
+  "voDKcKvXtyLzeZdx2g3Qn": {
+    "title": "ReAct Prompting",
+    "description": "",
+    "links": []
+  },
+  "6xaRB34_g0HGt-y1dGYXR": {
+    "title": "Manual Implementation",
+    "description": "",
+    "links": []
+  },
+  "Sm0Ne5Nx72hcZCdAcC0C2": {
+    "title": "OpenAI Functions / Tools",
+    "description": "",
+    "links": []
+  },
+  "mbp2NoL-VZ5hZIIblNBXt": {
+    "title": "OpenAI Assistant API",
+    "description": "",
+    "links": []
+  },
+  "W7cKPt_UxcUgwp8J6hS4p": {
+    "title": "Multimodal AI",
+    "description": "",
+    "links": []
+  },
+  "sGR9qcro68KrzM8qWxcH8": {
+    "title": "Multimodal AI Usecases",
+    "description": "",
+    "links": []
+  },
+  "fzVq4hGoa2gdbIzoyY1Zp": {
+    "title": "Image Understanding",
+    "description": "",
+    "links": []
+  },
+  "49BWxYVFpIgZCCqsikH7l": {
+    "title": "Image Generation",
+    "description": "",
+    "links": []
+  },
+  "TxaZCtTCTUfwCxAJ2pmND": {
+    "title": "Video Understanding",
+    "description": "",
+    "links": []
+  },
+  "mxQYB820447DC6kogyZIL": {
+    "title": "Audio Processing",
+    "description": "",
+    "links": []
+  },
+  "GCERpLz5BcRtWPpv-asUz": {
+    "title": "Text-to-Speech",
+    "description": "",
+    "links": []
+  },
+  "jQX10XKd_QM5wdQweEkVJ": {
+    "title": "Speech-to-Text",
+    "description": "",
+    "links": []
+  },
+  "CRrqa-dBw1LlOwVbrZhjK": {
+    "title": "OpenAI Vision API",
+    "description": "",
+    "links": []
+  },
+  "LKFwwjtcawJ4Z12X102Cb": {
+    "title": "DALL-E API",
+    "description": "",
+    "links": []
+  },
+  "OTBd6cPUayKaAM-fLWdSt": {
+    "title": "Whisper API",
+    "description": "",
+    "links": []
+  },
+  "EIDbwbdolR_qsNKVDla6V": {
+    "title": "Hugging Face Models",
+    "description": "",
+    "links": []
+  },
+  "j9zD3pHysB1CBhLfLjhpD": {
+    "title": "LangChain for Multimodal Apps",
+    "description": "",
+    "links": []
+  },
+  "akQTCKuPRRelj2GORqvsh": {
+    "title": "LlamaIndex for Multimodal Apps",
+    "description": "",
+    "links": []
+  },
+  "NYge7PNtfI-y6QWefXJ4d": {
+    "title": "Development Tools",
+    "description": "",
+    "links": []
+  },
+  "XcKeQfpTA5ITgdX51I4y-": {
+    "title": "AI Code Editors",
+    "description": "",
+    "links": []
+  },
+  "TifVhqFm1zXNssA8QR3SM": {
+    "title": "Code Completion Tools",
+    "description": "",
+    "links": []
+  }
+}

public/roadmap-content/devrel.json

@@ -0,0 +1,969 @@
+{
+  "SiYUdtYMDImRPmV2_XPkH": {
+    "title": "What is DevRel?",
+    "description": "DevRel, or Developer Relations, is a field that connects a company's technical products or services with the developer community. It encompasses community engagement, technical advocacy, feedback collection, content creation, event participation, and product evangelism.\n\nDevRel professionals build relationships with developers, educate them about company tools and APIs, gather insights for product improvement, produce technical content, represent the company at industry events, and promote technology adoption.\n\nThey typically possess both technical expertise and strong communication skills, serving as a vital link between external developers and internal engineering and product teams. DevRel aims to foster a positive ecosystem around a company's technology, driving adoption and user satisfaction.",
+    "links": []
+  },
+  "KP28dl1I9hxM130gIPxSZ": {
+    "title": "History and Evolution",
+    "description": "The first Developer Relations teams came about in the lates 80’s during fierce rivalry between Microsoft and Apple. Apple created a team of “Evangelists” and when Microsoft saw the large impact that this team were having on the sales and adoption of Apple products, they created a their own team of “Technical Evangelists” which later became the Microsoft Developer Relations Group.\n\nDevRel has since evolved into multiple roles within itself, including Developer Marketing, Developer Advocate and Developer Engineer.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Developer Relations History & Mission Structure",
+        "url": "https://lmcdunna.medium.com/developer-relations-history-mission-structure-5fcad869deac",
+        "type": "article"
+      },
+      {
+        "title": "History of Developer Evangelism",
+        "url": "https://www.youtube.com/watch?v=ieiQmyrmakI",
+        "type": "video"
+      }
+    ]
+  },
+  "No-UnhdGmtLW9uFGLy-ca": {
+    "title": "Developer Experience",
+    "description": "Developer Experience (DX) refers to the overall experience developers have while using a software product, tool, or platform. A positive DX is characterized by intuitive and well-documented APIs, robust and clear documentation, seamless integration processes, and responsive support. Good DX ensures that developers can efficiently build, deploy, and manage applications, reducing frustration and increasing productivity.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is developer experience?",
+        "url": "https://swimm.io/learn/developer-experience/what-is-developer-experience-devx-pillars-and-best-practices",
+        "type": "article"
+      },
+      {
+        "title": "Developer Experience: What is it and why should you care? GitHub",
+        "url": "https://github.blog/2023-06-08-developer-experience-what-is-it-and-why-should-you-care/",
+        "type": "article"
+      }
+    ]
+  },
+  "BooGiYTMoS0N5eobwjPHY": {
+    "title": "Developer Journey",
+    "description": "The Developer Journey encompasses the entire process that a developer goes through when interacting with a product or platform, from initial discovery to long-term engagement. This journey includes various stages such as awareness, onboarding, learning, building, deploying, and scaling. Each stage requires thoughtful design and support to ensure a smooth and positive experience. By understanding and optimizing each touchpoint in the Developer Journey, companies can reduce friction, enhance satisfaction, and foster a more loyal and productive developer community.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "The Developer Journey",
+        "url": "https://www.devrel.agency/developerjourney",
+        "type": "article"
+      },
+      {
+        "title": "Developer Relations: The Developer Journey Map",
+        "url": "https://medium.com/codex/developer-relations-the-developer-journey-map-36bd4619f5f3",
+        "type": "article"
+      },
+      {
+        "title": "Understand the developer journey",
+        "url": "https://www.commonroom.io/resources/ultimate-guide-to-developer-experience/",
+        "type": "article"
+      }
+    ]
+  },
+  "UhMk8g5MMhvi3kWLLI6B1": {
+    "title": "Developer Marketing",
+    "description": "Developer Marketing focuses on strategies and tactics to engage and attract developers to a product, platform, or service. It involves creating targeted content, such as technical blogs, tutorials, and case studies, that addresses developers' needs and pain points. Effective developer marketing also includes hosting events like hackathons, webinars, and conferences to build community and demonstrate value. By leveraging channels that developers trust, such as GitHub, Stack Overflow, and social media, companies can increase visibility and adoption of their offerings.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is developer marketing?",
+        "url": "https://appsembler.com/glossary/developer-marketing/",
+        "type": "article"
+      },
+      {
+        "title": "What is developer marketing? IronHorse.io",
+        "url": "https://ironhorse.io/blog/what-is-developer-marketing/",
+        "type": "article"
+      },
+      {
+        "title": "What is developer marketing (B2D)",
+        "url": "https://www.productmarketingalliance.com/what-is-developer-marketing/",
+        "type": "article"
+      }
+    ]
+  },
+  "N9HXTCQq2wfC-QurSofE_": {
+    "title": "Importance of DevRel",
+    "description": "Developer Relations (DevRel) is crucial for fostering a vibrant and engaged developer community around a product or platform. It involves creating and maintaining strong relationships with developers through activities like community building, technical support, advocacy, and education. Effective DevRel ensures that developers have the resources and support they need to succeed, which in turn drives product adoption, innovation, and loyalty. By bridging the gap between a company's development teams and external developers, DevRel can also provide valuable feedback for product improvements and help in shaping the future direction of the product or platform.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is Developer Relations? The Ultimate Guide for DevTool GTM Teams",
+        "url": "https://www.doc-e.ai/post/what-is-developer-relations-the-ultimate-guide-for-devtool-gtm-teams",
+        "type": "article"
+      },
+      {
+        "title": "DevRel - Why is it important?",
+        "url": "https://developers.onelogin.com/blog/devrel",
+        "type": "article"
+      },
+      {
+        "title": "The role of developer advocacy in driving innovation",
+        "url": "https://leaddev.com/process/role-developer-advocacy-driving-innovation",
+        "type": "article"
+      }
+    ]
+  },
+  "7MCmY1bABGPfmzjErADvg": {
+    "title": "Advocacy",
+    "description": "Developer Advocacy is the practice of representing and supporting the needs and interests of developers both within a company and in the broader developer community. Developer Advocates act as liaisons between the company’s development team and external developers, ensuring that the developers have the tools, resources, and knowledge to effectively use the company's products or platforms. They create educational content, provide technical support, gather feedback, and participate in community events.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is developer advocacy?",
+        "url": "https://appsembler.com/glossary/developer-advocacy/",
+        "type": "article"
+      },
+      {
+        "title": "The Developer Advocate Playbook: Your Go-To Guide to Turning Users into Champions 🚀",
+        "url": "https://www.doc-e.ai/post/the-developer-advocate-playbook-your-go-to-guide-to-turning-users-into-champions",
+        "type": "article"
+      },
+      {
+        "title": "Developer Relations: New Career Path for Developers",
+        "url": "https://www.youtube.com/watch?v=iA2SQ4OL4GU",
+        "type": "video"
+      }
+    ]
+  },
+  "EjqJkyojhO7f1uFHIoyGY": {
+    "title": "Education",
+    "description": "Developer Education focuses on providing developers with the knowledge and skills they need to effectively use a product, platform, or technology. This involves creating and delivering a variety of educational materials such as documentation, tutorials, courses, webinars, and interactive workshops. Effective developer education programs cater to different learning styles and levels of expertise, from beginners to advanced users.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is developer eduction?",
+        "url": "https://appsembler.com/glossary/developer-education/",
+        "type": "article"
+      },
+      {
+        "title": "What is developer education - Dev.to",
+        "url": "https://dev.to/jacobandrewsky/what-is-developer-education-5a01",
+        "type": "article"
+      },
+      {
+        "title": "Successful Developer Education: What you need to know",
+        "url": "https://www.developermarketing.io/successful-developer-education-what-you-need-to-know/",
+        "type": "article"
+      }
+    ]
+  },
+  "1NFcpGzCJylRPbFYdD9bB": {
+    "title": "Community Support",
+    "description": "Community Support in the context of Developer Relations (DevRel) involves actively engaging with and assisting the developer community to foster a collaborative and supportive environment. This includes moderating forums, responding to queries, organizing community events, and facilitating peer-to-peer support. Effective community support ensures that developers feel heard and valued, and have access to timely and accurate assistance, which enhances their overall experience and productivity.",
+    "links": [
+      {
+        "title": "Community and DevRel",
+        "url": "https://developerrelations.com/podcast/community-and-devrel",
+        "type": "article"
+      },
+      {
+        "title": "New to DevRel? Talk to your community!",
+        "url": "https://dev.to/amandamartindev/new-to-devrel-talk-to-your-community-hmf",
+        "type": "article"
+      },
+      {
+        "title": "DevRel & Community",
+        "url": "https://www.youtube.com/watch?v=CfXkY2m_0dU",
+        "type": "video"
+      }
+    ]
+  },
+  "_3ZnPUl4kzzuM0bKQ8IAq": {
+    "title": "Content Creation",
+    "description": "Content creation in the context of Developer Relations (DevRel) involves producing a wide range of materials designed to educate, engage, and empower developers. This includes writing technical blogs, creating video tutorials, developing comprehensive documentation, and crafting code samples and demos. The goal is to provide valuable resources that help developers understand and effectively use a product or platform. High-quality content addresses common challenges, showcases best practices, and highlights new features or updates.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "The secret of content creation for DevRel",
+        "url": "https://developerrelations.com/dev-rel/the-secrets-of-content-creation-for-devrels",
+        "type": "article"
+      },
+      {
+        "title": "Content strategy for DevRel teams",
+        "url": "https://www.stephaniemorillo.co/post/content-strategy-for-devrel-teams-a-primer",
+        "type": "article"
+      },
+      {
+        "title": "DevRel Content Creation with Stephanie Wong from Google Cloud",
+        "url": "https://www.youtube.com/watch?v=DQE1hBXVXYA",
+        "type": "video"
+      }
+    ]
+  },
+  "IxRvVvX9Fax08YUbVob4s": {
+    "title": "Feedback Loop",
+    "description": "Feedback loops are a crucial process that involves collecting, analyzing, and acting on feedback from developers to improve products and services. This loop begins with gathering insights through various channels such as forums, surveys, social media, direct interactions at events, and support tickets. The feedback is then communicated to internal teams, including product management, engineering, and marketing, to inform product enhancements, feature requests, and bug fixes.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Harnessing the Power of Community Feedback for Product Development",
+        "url": "https://draft.dev/learn/devrel-harnessing-the-power-of-community-feedback-for-product-development",
+        "type": "article"
+      },
+      {
+        "title": "The Developer Advocacy Feedback Loop",
+        "url": "https://glaforge.dev/talks/2020/08/06/the-developer-advocacy-feedback-loop/",
+        "type": "article"
+      }
+    ]
+  },
+  "LRZ8yxTfEGCXsYp4N1_uD": {
+    "title": "Public Speaking",
+    "description": "",
+    "links": []
+  },
+  "0ntOE6PSdMl_EXB9gdgIv": {
+    "title": "Writing Skills",
+    "description": "Good writing skills are crucial for software developers because they enhance communication, documentation, and collaboration. Clear and concise writing ensures that complex technical concepts are easily understood by team members, stakeholders, and end-users. Effective documentation, including comments, user manuals, and technical guides, helps maintain code quality and facilitates future maintenance and updates. Writing also plays a key role in crafting clear commit messages, bug reports, and project proposals, which are essential for smooth project management and collaboration. In an increasingly global and remote work environment, the ability to articulate ideas and solutions in writing becomes even more vital, ensuring that everyone is on the same page and can contribute effectively to the project's success.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Putting Ideas into Words",
+        "url": "https://www.paulgraham.com/words.html",
+        "type": "article"
+      },
+      {
+        "title": "Patterns in confusing explanations",
+        "url": "https://jvns.ca/blog/confusing-explanations/",
+        "type": "article"
+      },
+      {
+        "title": "Signposting: How to reduce cognitive load for your reader",
+        "url": "https://newsletter.weskao.com/p/sign-posting-how-to-reduce-cognitive",
+        "type": "article"
+      }
+    ]
+  },
+  "c0w241EL0Kh4ek76IgsEs": {
+    "title": "Blog Posts",
+    "description": "",
+    "links": []
+  },
+  "X0xUzEP0S6SyspvqyoDDk": {
+    "title": "Technical Documentation",
+    "description": "Technical documentation refers to the process of creating and maintaining written descriptions of software, hardware, and other technical products or systems. It involves communicating complex information in a clear, concise, and organized manner to help users understand, operate, and maintain the product or system. Effective technical documentation can take many forms, including user manuals, guides, tutorials, release notes, and API documentation, and is typically created by technical writers, developers, and subject matter experts. The goal of technical documentation is to provide accurate, up-to-date, and easily accessible information that enables users to get the most out of a product or system, while also reducing support queries and improving overall user experience.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Technical Writer Roadmap",
+        "url": "https://roadmap.sh/technical-writer",
+        "type": "article"
+      },
+      {
+        "title": "Technical Writing - MDN Docs",
+        "url": "https://developer.mozilla.org/en-US/blog/technical-writing/",
+        "type": "article"
+      },
+      {
+        "title": "Technical Documentation - Wikipedia",
+        "url": "https://en.wikipedia.org/wiki/Technical_documentation",
+        "type": "article"
+      }
+    ]
+  },
+  "urbtoZtuJryK-6TJ3lmRN": {
+    "title": "Social Media",
+    "description": "",
+    "links": []
+  },
+  "PFjF2PnYpSbvd24jb_D2G": {
+    "title": "Presentation Techniques",
+    "description": "",
+    "links": []
+  },
+  "vH_ECVYSQ3Fg-DASO1EgK": {
+    "title": "Rules of Three",
+    "description": "",
+    "links": []
+  },
+  "_FZNqUKgPkzbgOPoiSLSU": {
+    "title": "PechaKucha",
+    "description": "",
+    "links": []
+  },
+  "Y0GUZynSXjITDOA-TP6LH": {
+    "title": "Storytelling",
+    "description": "",
+    "links": []
+  },
+  "uwvvWmcZnFqLoHRDFXFyW": {
+    "title": "Mind Mapping",
+    "description": "",
+    "links": []
+  },
+  "SNhrYZsmyDHN_JWh0eZy2": {
+    "title": "Visualization",
+    "description": "",
+    "links": []
+  },
+  "iKYmUvWFT_C0wnO0iB6gM": {
+    "title": "Engaging Audience",
+    "description": "",
+    "links": []
+  },
+  "VTGsmk3p4RVXiNhDmx2l8": {
+    "title": "The Hook",
+    "description": "",
+    "links": []
+  },
+  "LixiZj3-QcmQgGAqaaDr6": {
+    "title": "Contrast Principle",
+    "description": "",
+    "links": []
+  },
+  "tbIAEStaoVWnEWbdk7EGc": {
+    "title": "Handouts",
+    "description": "",
+    "links": []
+  },
+  "2iRt9E42i_ej4woKCW_s2": {
+    "title": "Repetition & Reinforcement",
+    "description": "",
+    "links": []
+  },
+  "Xf-Lxi1cKReo4yDLylBbL": {
+    "title": "Handling Q&A",
+    "description": "",
+    "links": []
+  },
+  "UdUDngq425NYSvIuOd7St": {
+    "title": "Active Listening",
+    "description": "",
+    "links": []
+  },
+  "jyScVS-sYMcZcH3hOwbMK": {
+    "title": "Anticipate Questions",
+    "description": "",
+    "links": []
+  },
+  "rhs6QwxZ7PZthLfi38FJn": {
+    "title": "Be Concise",
+    "description": "",
+    "links": []
+  },
+  "VSOdD9KKF_Qz8nbRdHNo3": {
+    "title": "Managing Difficult Questions",
+    "description": "",
+    "links": []
+  },
+  "yJygbi8cnp3oz2EFl2MR0": {
+    "title": "Community Engagement",
+    "description": "Building a positive developer experience through community engagement is an ongoing process that requires dedication, empathy, and a genuine commitment to your users. By investing in a welcoming environment, facilitating knowledge sharing, and leveraging AI-powered tools like [Doc-E.ai](http://Doc-E.ai), you can create a thriving community that not only supports your product but also becomes a source of innovation, loyalty, and growth.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "The Ultimate Guide to Developer Engagement and Community Building: Unlocking the Power of Developer-Centric Growth",
+        "url": "https://www.doc-e.ai/post/the-ultimate-guide-to-developer-engagement-and-community-building-unlocking-the-power-of-developer-centric-growth",
+        "type": "article"
+      },
+      {
+        "title": "Fostering a Positive Developer Experience Through Community Engagement: A Blueprint for DevTool Success",
+        "url": "https://www.doc-e.ai/post/fostering-a-positive-developer-experience-through-community-engagement-a-blueprint-for-devtool-success",
+        "type": "article"
+      }
+    ]
+  },
+  "C2w8R4tNy2lOhhWU9l32s": {
+    "title": "Event Participation",
+    "description": "",
+    "links": []
+  },
+  "gvMbo22eRxqOzszc_w4Gz": {
+    "title": "Online Communities",
+    "description": "",
+    "links": []
+  },
+  "SJf9e7SQnzYVHoRWl0i6P": {
+    "title": "Networking",
+    "description": "",
+    "links": []
+  },
+  "aSYXa25_0O2qQl1O-N3xl": {
+    "title": "Basic Programming Skills",
+    "description": "Basic programming skills are essential for Developer Relations professionals to effectively communicate with developers, understand their needs, and provide technical support. These skills include proficiency in at least one programming language, understanding of data structures and algorithms, and familiarity with development tools and technologies. Having basic programming skills enables Developer Relations professionals to create educational content, provide technical guidance, and participate in code reviews.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "TheNewStack.io - Devrel",
+        "url": "https://thenewstack.io/devrel-for-beginners-how-to-get-started/",
+        "type": "article"
+      },
+      {
+        "title": "Getting Started With Devrel- Dev.to",
+        "url": "https://dev.to/rejoice/getting-started-with-devrel-22n3",
+        "type": "article"
+      },
+      {
+        "title": "How to become a DevRel",
+        "url": "https://www.pluralsight.com/resources/blog/tech-operations/developer-relations-getting-a-devrel-job",
+        "type": "article"
+      }
+    ]
+  },
+  "KdFYmj36M2jrGfsYkukpo": {
+    "title": "IDEs",
+    "description": "The concept of Integrated Development Environments (IDEs) traces its roots back to the 1960s and 1970s when basic text editors and simple programming tools were used in early computing. The first notable IDEs emerged with the rise of Unix systems in the 1970s, such as the EMACS text editor, which included features like code editing and debugging. Today, IDEs have become essential for developers, supporting multiple programming languages and integrating cloud-based tools, continuous integration, and real-time collaboration. IDEs like Visual Studio Code, IntelliJ IDEA, and Eclipse are widely adopted by developers across industries.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "History of IDEs",
+        "url": "https://multiqos.com/blogs/guide-to-integrated-development-environment/#:~:text=While%20TurboPascal%20may%20have%20popularized,significant%20popularity%20in%20the%201980s.",
+        "type": "article"
+      },
+      {
+        "title": "Visual Studio Code",
+        "url": "https://code.visualstudio.com/",
+        "type": "article"
+      },
+      {
+        "title": "JetBrains IDEs",
+        "url": "https://www.jetbrains.com/",
+        "type": "article"
+      }
+    ]
+  },
+  "j5nNSYI8s-cH8EA6G1EWY": {
+    "title": "VS Code",
+    "description": "Visual Studio Code (VSCode) was first announced by Microsoft in 2015 and quickly became one of the most popular and widely used Integrated Development Environments (IDEs). Built on Electron, a framework that allows web technologies like JavaScript, HTML, and CSS to create desktop applications, VSCode offers a lightweight and highly extensible platform for developers. VSCode focuses on being a streamlined code editor with the ability to install extensions that add features such as debugging, version control, and language-specific tooling. Microsoft's vision was to create a flexible environment that could cater to all types of developers, from beginners to seasoned professionals.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Visual Studio Code",
+        "url": "https://code.visualstudio.com/",
+        "type": "article"
+      },
+      {
+        "title": "Docs - Visual Studio Code",
+        "url": "https://code.visualstudio.com/docs",
+        "type": "article"
+      },
+      {
+        "title": "FreeCodeCamp Crash Course",
+        "url": "https://www.youtube.com/watch?v=WPqXP_kLzpo",
+        "type": "video"
+      },
+      {
+        "title": "VSCode Basics",
+        "url": "https://www.youtube.com/watch?v=B-s71n0dHUk",
+        "type": "video"
+      },
+      {
+        "title": "VSCode in 100 Seconds",
+        "url": "https://www.youtube.com/watch?v=KMxo3T_MTvY",
+        "type": "video"
+      }
+    ]
+  },
+  "NCnKS435DCl-8vilr1_XE": {
+    "title": "JetBrains IDEs",
+    "description": "",
+    "links": []
+  },
+  "sUEZHmKxtjO9gXKJoOdbF": {
+    "title": "APIs & SDKs",
+    "description": "",
+    "links": []
+  },
+  "pqp9FLRJRDDEnni72KHmv": {
+    "title": "Writing Documentation",
+    "description": "",
+    "links": []
+  },
+  "h6R3Vyq0U8t8WL3G5xC2l": {
+    "title": "Building SDKs",
+    "description": "",
+    "links": []
+  },
+  "7Q6_tdRaeb8BgreG8Mw-a": {
+    "title": "Understanding APIs",
+    "description": "",
+    "links": []
+  },
+  "x6KFf4akYuUYkNhrUwj1r": {
+    "title": "Version Control",
+    "description": "",
+    "links": []
+  },
+  "a-i1mgF3VAxbbpA1gMWyK": {
+    "title": "Git",
+    "description": "",
+    "links": []
+  },
+  "8O1AgUKXe35kdiYD02dyt": {
+    "title": "GitHub",
+    "description": "",
+    "links": []
+  },
+  "J2WunUJBzYw_D5cQH_pnH": {
+    "title": "Managing Discussions",
+    "description": "",
+    "links": []
+  },
+  "vCoEJyS4qMWTTiL17PmWr": {
+    "title": "Issues & Pull Requests",
+    "description": "",
+    "links": []
+  },
+  "x3qTqhR1uA5CXqULIJqL8": {
+    "title": "Labelling and Cleanup",
+    "description": "",
+    "links": []
+  },
+  "v_lDqjtxjRK67GsbtxXgT": {
+    "title": "Milestones & Releases",
+    "description": "",
+    "links": []
+  },
+  "7ZFTmlQHYQKNjKprwV8zk": {
+    "title": "Public Backlog",
+    "description": "",
+    "links": []
+  },
+  "GvmXdWiwITgWzx_f5_ick": {
+    "title": "Building a Community",
+    "description": "Online developer communities have become the heart of successful DevTools (Developer Tools) go-to-market (GTM) strategies. They provide a platform for developers to connect, collaborate, learn, and share their expertise, ultimately fostering loyalty, driving product adoption, and fueling innovation.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Building and Nurturing Online Developer Communities: The Ultimate Guide",
+        "url": "https://www.doc-e.ai/post/building-and-nurturing-online-developer-communities-the-ultimate-guide",
+        "type": "article"
+      },
+      {
+        "title": "10 Proven Strategies for Building a Developer Community That Thrives: A Guide to Inclusion & Engagement",
+        "url": "https://dev.to/swati1267/10-proven-strategies-for-building-a-developer-community-that-thrives-a-guide-to-inclusion-engagement-21cm",
+        "type": "article"
+      }
+    ]
+  },
+  "UKi3waPx2pozvZf2aQ52s": {
+    "title": "Identifying Audience",
+    "description": "",
+    "links": []
+  },
+  "WItTQ1QboHoRkqeHJzCM9": {
+    "title": "Platform Selection",
+    "description": "",
+    "links": []
+  },
+  "hPJM4QXxeqTxPlvJ2_D3_": {
+    "title": "Initial Outreach",
+    "description": "",
+    "links": []
+  },
+  "4ZvzY_xGO5BZOmfqj0TTq": {
+    "title": "Community Guidelines",
+    "description": "",
+    "links": []
+  },
+  "er9ukuBvY-F4F8S1qbbjU": {
+    "title": "Code of Conduct",
+    "description": "",
+    "links": []
+  },
+  "8I59U-nnkhQv8ldRuqQlb": {
+    "title": "Rules and Policies",
+    "description": "",
+    "links": []
+  },
+  "-6cf3RT4-cbwvLYIkCosF": {
+    "title": "Community Management",
+    "description": "",
+    "links": []
+  },
+  "d_dKF87OnRWoWj3Bf1uFf": {
+    "title": "Moderation",
+    "description": "",
+    "links": []
+  },
+  "8ls5kQvDgvwLbIrwYg1OL": {
+    "title": "Conflict Resolution",
+    "description": "",
+    "links": []
+  },
+  "6yLt4Ia52Jke9i5kJQvAC": {
+    "title": "Encouraging Participation",
+    "description": "",
+    "links": []
+  },
+  "Nta8pUncwNQxJlqF6h1AT": {
+    "title": "Recognition Programs",
+    "description": "",
+    "links": []
+  },
+  "usorG1GkkvGAZ0h_AGHVk": {
+    "title": "Event Management",
+    "description": "",
+    "links": []
+  },
+  "RQk3uOikjQYRyTu7vuAG7": {
+    "title": "Planning",
+    "description": "",
+    "links": []
+  },
+  "C9--J8gGZENQKn-QcZK4M": {
+    "title": "Promotion",
+    "description": "",
+    "links": []
+  },
+  "1m1keusP-PTjEwy0dCJJL": {
+    "title": "Execution",
+    "description": "",
+    "links": []
+  },
+  "kmcOYDvu1vq7AQPllZvv0": {
+    "title": "Post Event Followup",
+    "description": "",
+    "links": []
+  },
+  "_Qe_0RksYpX7Spzgc6Fw3": {
+    "title": "Surveys",
+    "description": "",
+    "links": []
+  },
+  "oWXfov-mOF47d7Vffyp3t": {
+    "title": "Feedback Collection",
+    "description": "",
+    "links": []
+  },
+  "B1IdobUaGeBLI2CgsFg8H": {
+    "title": "Blogging",
+    "description": "",
+    "links": []
+  },
+  "uzMfR6Yd9Jvjn8i5RpC1Q": {
+    "title": "Topic Selection",
+    "description": "",
+    "links": []
+  },
+  "l6-mzgDTXg2EPkyZyZ6TC": {
+    "title": "Writing Process",
+    "description": "",
+    "links": []
+  },
+  "zVBy8o66FdZueg-2v3gaw": {
+    "title": "SEO Basics",
+    "description": "",
+    "links": []
+  },
+  "2QiQW9tygpeaES8Wp1Kw6": {
+    "title": "Guest Blogging",
+    "description": "",
+    "links": []
+  },
+  "nlzI2fG3SwC5Q42qXcXPX": {
+    "title": "Cross-Promotion",
+    "description": "",
+    "links": []
+  },
+  "w1ZooDCDOkbL1EAa5Hx3d": {
+    "title": "Collaborations",
+    "description": "",
+    "links": []
+  },
+  "bRzzc137OlmivEGdhv5Ew": {
+    "title": "Video Production",
+    "description": "",
+    "links": []
+  },
+  "6zK9EJDKBC89UArY7sfgs": {
+    "title": "Editing",
+    "description": "",
+    "links": []
+  },
+  "_QHUpFW4kZ5SBaP7stXY2": {
+    "title": "Recording",
+    "description": "",
+    "links": []
+  },
+  "rLDRkUht9K1m4noMAIgKU": {
+    "title": "Scripting",
+    "description": "",
+    "links": []
+  },
+  "OUWVqJImrmsZpAtRrUYNH": {
+    "title": "Animations & Graphics",
+    "description": "",
+    "links": []
+  },
+  "pEMNcm_wJNmOkWm57L1pA": {
+    "title": "Video Production",
+    "description": "",
+    "links": []
+  },
+  "iPaFjacZ7hSWriSEqUmHc": {
+    "title": "Live Streaming",
+    "description": "",
+    "links": []
+  },
+  "Mdp4bBlhVbGohJkVlsDar": {
+    "title": "X",
+    "description": "",
+    "links": []
+  },
+  "OY5rn3XTbmz4LzSLRcNmw": {
+    "title": "YouTube",
+    "description": "",
+    "links": []
+  },
+  "QlWam-kHv8G_-yx3ClP9s": {
+    "title": "Twitch",
+    "description": "",
+    "links": []
+  },
+  "meZDgDJMy4aH5VqS-NJL4": {
+    "title": "Streamyard",
+    "description": "",
+    "links": []
+  },
+  "D7_iNPEKxFv0gw-fsNNrZ": {
+    "title": "Animations & Graphics",
+    "description": "",
+    "links": []
+  },
+  "8aiLVG4clveX1Luiehvxr": {
+    "title": "Technical Setup",
+    "description": "",
+    "links": []
+  },
+  "tRywPj_2VyjSLjxYJtYZd": {
+    "title": "Video",
+    "description": "",
+    "links": []
+  },
+  "7y4vHk_jgNTW6Q1WoqYDc": {
+    "title": "Audio",
+    "description": "",
+    "links": []
+  },
+  "71BBFjaON1NJi4rOHKW6K": {
+    "title": "Social Media",
+    "description": "",
+    "links": []
+  },
+  "6BqkO4XOspJg0-9GNLtUp": {
+    "title": "X",
+    "description": "",
+    "links": []
+  },
+  "6UR59TigEZ0NaixbaUIqn": {
+    "title": "LinkedIn",
+    "description": "",
+    "links": []
+  },
+  "ZMManUnO-9EQqi-xmLt5r": {
+    "title": "Facebook",
+    "description": "",
+    "links": []
+  },
+  "UAkGV9_I6qiKZMr1aqQCm": {
+    "title": "Instagram",
+    "description": "",
+    "links": []
+  },
+  "TGXPxTFv9EhsfS5uWR5gS": {
+    "title": "Content Strategy",
+    "description": "",
+    "links": []
+  },
+  "lG1FH7Q-YX5pG-7mMtbSR": {
+    "title": "Analytics and Optimization",
+    "description": "",
+    "links": []
+  },
+  "l2P44pL9eF8xarBwC_CVO": {
+    "title": "Consistent Posting",
+    "description": "",
+    "links": []
+  },
+  "WIH216mHg2OiSebzQYI-f": {
+    "title": "Engaging Content",
+    "description": "",
+    "links": []
+  },
+  "ZWkpgvXIzjN3_fOyhVEv0": {
+    "title": "Creating Brand Voice",
+    "description": "",
+    "links": []
+  },
+  "NWxAxiDgvlGpvqdkzqnOH": {
+    "title": "Tracking Engagement",
+    "description": "",
+    "links": []
+  },
+  "46iMfYgC7fCZLCy-qzl1B": {
+    "title": "Data-Driven Strategy Shift",
+    "description": "",
+    "links": []
+  },
+  "g3M6nfLr0DMcn-NCFF7nZ": {
+    "title": "Documentation",
+    "description": "",
+    "links": []
+  },
+  "RLf08xKMjlt6S9-MFiTo-": {
+    "title": "User Guides",
+    "description": "",
+    "links": []
+  },
+  "7IJO_jDpZUdlr_n5rBJ6O": {
+    "title": "API References",
+    "description": "",
+    "links": []
+  },
+  "6ubk20TBIL3_VrrRMe8tO": {
+    "title": "Tutorials",
+    "description": "",
+    "links": []
+  },
+  "xy9Kqtwrh5IhYHaqEhvl_": {
+    "title": "Sample Projects",
+    "description": "",
+    "links": []
+  },
+  "pGJrCyYhLLGUnv6LxpYUe": {
+    "title": "Code Samples",
+    "description": "",
+    "links": []
+  },
+  "mWcMSKnUQamUykBxND-Ju": {
+    "title": "Example Apps",
+    "description": "",
+    "links": []
+  },
+  "omnUSgUHZg2DmnOUJ0Xo1": {
+    "title": "Use Case Based",
+    "description": "",
+    "links": []
+  },
+  "LwNa3u9Lf88ju5w7CvSN5": {
+    "title": "Support",
+    "description": "",
+    "links": []
+  },
+  "oGTIvAY3zYgoiC63FQRSd": {
+    "title": "Forums",
+    "description": "",
+    "links": []
+  },
+  "j6tr3mAaKqTuEFTRSCsrK": {
+    "title": "Issue Tracking",
+    "description": "",
+    "links": []
+  },
+  "4GCQ3stXxW1HrlAVC0qDl": {
+    "title": "FAQs",
+    "description": "",
+    "links": []
+  },
+  "weyCcboaekqf5NuVAOxfU": {
+    "title": "Office Hours",
+    "description": "",
+    "links": []
+  },
+  "1fc0iWwOkheUJ7d0np86L": {
+    "title": "Webinars",
+    "description": "",
+    "links": []
+  },
+  "DCj1teu8Hp82EKnakFRPn": {
+    "title": "Key Metrics",
+    "description": "",
+    "links": []
+  },
+  "afR1VviBs2w0k8UmP38vn": {
+    "title": "Community Growth",
+    "description": "",
+    "links": []
+  },
+  "RXj0yB7KsIOM5whwtyBBU": {
+    "title": "Engagement Rates",
+    "description": "",
+    "links": []
+  },
+  "yhDBZfUAjumFHpUZtmLg3": {
+    "title": "Content Performance",
+    "description": "",
+    "links": []
+  },
+  "AwMwMU9hg_gCKPP4tykHb": {
+    "title": "Developer Satisfaction",
+    "description": "",
+    "links": []
+  },
+  "psk3bo-nSskboAoVTjlpz": {
+    "title": "Tools",
+    "description": "",
+    "links": []
+  },
+  "8xrhjG9qmbsoBC3F8zS-b": {
+    "title": "Google Analytics",
+    "description": "",
+    "links": []
+  },
+  "x8RIrK2VB-LBFbt6hAcQb": {
+    "title": "Social Media Analytics",
+    "description": "",
+    "links": []
+  },
+  "AL3-UzREwTpsADTU0YtRW": {
+    "title": "Platform Specific Analytics",
+    "description": "",
+    "links": []
+  },
+  "N1uh7dVKfSPT7w0MlKzWO": {
+    "title": "Reporting",
+    "description": "",
+    "links": []
+  },
+  "U2QKCu6TvDuxSNRfdM74n": {
+    "title": "Regular Reports",
+    "description": "",
+    "links": []
+  },
+  "0dRnUlgze87eq2FVU_mWp": {
+    "title": "Data Visualization",
+    "description": "",
+    "links": []
+  },
+  "mh1BZDVkc-VwA8aQAmDhO": {
+    "title": "Insights & Recommendations",
+    "description": "",
+    "links": []
+  },
+  "wcfrXA9zWZ4Taey7mR2yG": {
+    "title": "Thought Leadership",
+    "description": "",
+    "links": []
+  },
+  "I7RBMfoD30OstVLeTrMs9": {
+    "title": "Publishing",
+    "description": "",
+    "links": []
+  },
+  "QrDqUGWC2t9r6p4aR8I5g": {
+    "title": "Media Appearances",
+    "description": "",
+    "links": []
+  },
+  "ue0NaNnNpF7UhvJ8j0Yuo": {
+    "title": "Conference Speaking",
+    "description": "",
+    "links": []
+  },
+  "HN2gNsYYRLVOOdy_r8FKJ": {
+    "title": "Building a Personal Brand",
+    "description": "",
+    "links": []
+  },
+  "4ygpqUK70hI5r1AmmfMZq": {
+    "title": "Networking Strategies",
+    "description": "",
+    "links": []
+  },
+  "HIIqlnZ4Vad_1o4F0lkv-": {
+    "title": "Meetups",
+    "description": "",
+    "links": []
+  },
+  "lMbj0WdoEia_tdpO5rXph": {
+    "title": "Online Communities",
+    "description": "",
+    "links": []
+  },
+  "NhQUDVA9q1hnV44EKapbU": {
+    "title": "Open-Source",
+    "description": "",
+    "links": []
+  },
+  "bwwk6ESNyEJa3fCAIKPwh": {
+    "title": "Continuous Learning",
+    "description": "",
+    "links": []
+  }
+}

public/roadmap-content/full-stack.json

@@ -0,0 +1,837 @@
+{
+  "B0kARTODvCBi0iOF8iiqI": {
+    "title": "HTML",
+    "description": "HTML stands for HyperText Markup Language. It is used on the frontend and gives the structure to the webpage which you can style using CSS and make interactive using JavaScript.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "W3Schools: Learn HTML",
+        "url": "https://www.w3schools.com/html/html_intro.asp",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about HTML",
+        "url": "https://app.daily.dev/tags/html?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "HTML Full Course for Beginners",
+        "url": "https://youtu.be/mJgBOIoGihA",
+        "type": "video"
+      },
+      {
+        "title": "HTML Full Course - Build a Website Tutorial",
+        "url": "https://www.youtube.com/watch?v=pQN-pnXPaVg",
+        "type": "video"
+      }
+    ]
+  },
+  "dAJHWmGeiYdzZ1ZjrWz1S": {
+    "title": "CSS",
+    "description": "CSS or Cascading Style Sheets is the language used to style the frontend of any website. CSS is a cornerstone technology of the World Wide Web, alongside HTML and JavaScript.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "W3Schools — Learn CSS",
+        "url": "https://www.w3schools.com/css/",
+        "type": "article"
+      },
+      {
+        "title": "Web.dev by Google — Learn CSS",
+        "url": "https://web.dev/learn/css/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about CSS",
+        "url": "https://app.daily.dev/tags/css?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "CSS Complete Course",
+        "url": "https://youtu.be/n4R2E7O-Ngo",
+        "type": "video"
+      },
+      {
+        "title": "HTML and CSS Tutorial",
+        "url": "https://www.youtube.com/watch?v=D-h8L5hgW-w",
+        "type": "video"
+      }
+    ]
+  },
+  "T9PB6WQf-Fa9NXKKvVOy_": {
+    "title": "JavaScript",
+    "description": "JavaScript allows you to add interactivity to your pages. Common examples that you may have seen on the websites are sliders, click interactions, popups and so on.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Visit Dedicated JavaScript Roadmap",
+        "url": "https://roadmap.sh/javascript",
+        "type": "article"
+      },
+      {
+        "title": "The Modern JavaScript Tutorial",
+        "url": "https://javascript.info/",
+        "type": "article"
+      },
+      {
+        "title": "Build 30 Javascript projects in 30 days",
+        "url": "https://javascript30.com/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about JavaScript",
+        "url": "https://app.daily.dev/tags/javascript?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "JavaScript Crash Course for Beginners",
+        "url": "https://youtu.be/hdI2bqOjy3c?t=2",
+        "type": "video"
+      }
+    ]
+  },
+  "mGgx_QTEPmVKf6AijX9fi": {
+    "title": "npm",
+    "description": "npm is a package manager for the JavaScript programming language maintained by npm, Inc. npm is the default package manager for the JavaScript runtime environment Node.js.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "How to NPM",
+        "url": "https://github.com/workshopper/how-to-npm",
+        "type": "opensource"
+      },
+      {
+        "title": "Modern JavaScript for Dinosaurs",
+        "url": "https://peterxjang.com/blog/modern-javascript-explained-for-dinosaurs.html",
+        "type": "article"
+      },
+      {
+        "title": "An Absolute Beginners Guide to Using npm",
+        "url": "https://nodesource.com/blog/an-absolute-beginners-guide-to-using-npm/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about NPM",
+        "url": "https://app.daily.dev/tags/npm?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "NPM tutorial for Beginners",
+        "url": "https://www.youtube.com/watch?v=2V1UUhBJ62Y",
+        "type": "video"
+      },
+      {
+        "title": "NPM Crash Course",
+        "url": "https://www.youtube.com/watch?v=jHDhaSSKmB0",
+        "type": "video"
+      }
+    ]
+  },
+  "WsdUAEaI7FX6DKKhPXUHp": {
+    "title": "Checkpoint - Static Webpages",
+    "description": "Now that you have learnt HTML and CSS, you should be able to build static webpages. I recommend you to build as many test projects at each yellow step of the roadmap as possible to solidify what you learn.\n\nThe practice that I used to follow when I was learning was this:\n\n*   While you are watching a course or reading a book, make sure to code along with the instructor/author — pause the video at regular intervals and code what you are being taught.\n*   Search on YouTube and watch a few project based tutorials on the topic that you are learning. Apart from coding along with the instructor:\n    *   Try to build the same project at least 2 to 3 times on your own without looking at the video. If you get stuck, refer to the section of the video where the instructor builds that part of the project.\n    *   Build something else that is similar to the project that you just built. For example, if you just built a todo app, try to build a notes app or a reminder app.\n\nProject Ideas\n-------------\n\nNow that you have learnt HTML and CSS, here are a few ideas for you to build:\n\n*   Try to copy the design of a website that you like.\n    *   Here is a [simple blog design in figma](https://www.figma.com/file/nh0V05z3NB87ue9v5PcO3R/writings.dev?type=design&node-id=0%3A1&t=2iQplaIojU3ydAfW-1) that you can try to copy.\n    *   Or try to rebuild the [webpages of this website](https://cs.fyi/).\n*   Take some inspiration from [personal portfolios of others](https://astro.build/showcase/) and build your own personal portfolio",
+    "links": []
+  },
+  "2DFzoIUjKdAKGjfu_SCfa": {
+    "title": "Checkpoint - Interactivity",
+    "description": "At this point you should be able to add interactivity to your web pages using JavaScript. You should make sure that you have learnt the following:\n\n*   Know about variables, loops, data types, conditionals, functions.\n*   Know about arrays and objects and different ways to access their data.\n*   Know how to select DOM elements.\n*   Add event listeners to DOM elements (e.g. click, focus, form submission).\n*   Use JavaScript to add and remove DOM elements\n*   Add and remove classes from DOM elements\n*   Use JavaScript to make HTTP requests to external APIs (i.e. `fetch`)\n*   Use JavaScript to store data in the browser's local storage\n\nHere are few ideas to practice your skills:\n\n*   Create a simple to-do list app that allows users to search, add, edit, and delete items. Use local storage to store the data.\n*   Create a simple webpage where user can put in anyone's GitHub username and see their profile information. You can use GitHub's API to fetch the data. For example, here is the [sample URL to fetch my data](https://api.github.com/users/kamranahmedse). Make sure to add validation and error handling.\n*   Create a basic calculator app that allows users to perform basic arithmetic operations.",
+    "links": []
+  },
+  "We2APJpOPTr-VNfowG0kI": {
+    "title": "Git",
+    "description": "[Git](https://git-scm.com/) is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Learn Git with Tutorials, News and Tips - Atlassian",
+        "url": "https://www.atlassian.com/git",
+        "type": "article"
+      },
+      {
+        "title": "Git Cheat Sheet",
+        "url": "https://cs.fyi/guide/git-cheatsheet",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Git",
+        "url": "https://app.daily.dev/tags/git?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Git & GitHub Crash Course For Beginners",
+        "url": "https://www.youtube.com/watch?v=SWYqp7iY_Tc",
+        "type": "video"
+      },
+      {
+        "title": "Git Tutorial For Dummies",
+        "url": "https://www.youtube.com/watch?v=mJ-qvsxPHpY",
+        "type": "video"
+      }
+    ]
+  },
+  "8sPXL8iClpPqje03ksses": {
+    "title": "GitHub",
+    "description": "GitHub is a provider of Internet hosting for software development and version control using Git. It offers the distributed version control and source code management functionality of Git, plus its own features.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "GitHub Website",
+        "url": "https://github.com",
+        "type": "opensource"
+      },
+      {
+        "title": "GitHub Documentation",
+        "url": "https://docs.github.com/en/get-started/quickstart",
+        "type": "article"
+      },
+      {
+        "title": "How to Use Git in a Professional Dev Team",
+        "url": "https://ooloo.io/project/github-flow",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about GitHub",
+        "url": "https://app.daily.dev/tags/github?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "What is GitHub?",
+        "url": "https://www.youtube.com/watch?v=w3jLJU7DT5E",
+        "type": "video"
+      },
+      {
+        "title": "Git vs. GitHub: Whats the difference?",
+        "url": "https://www.youtube.com/watch?v=wpISo9TNjfU",
+        "type": "video"
+      },
+      {
+        "title": "Git and GitHub for Beginners",
+        "url": "https://www.youtube.com/watch?v=RGOj5yH7evk",
+        "type": "video"
+      },
+      {
+        "title": "Git and GitHub - CS50 Beyond 2019",
+        "url": "https://www.youtube.com/watch?v=eulnSXkhE7I",
+        "type": "video"
+      }
+    ]
+  },
+  "R4aeJNOrfWyVp3ea-qF4H": {
+    "title": "Checkpoint - External Packages",
+    "description": "At this point, you should be able to install and use external packages using `npm`. You probably know about [npmjs.com](https://npmjs.com/) where you can search for packages and read their documentation. You should also be familiar with the `package.json` file and how to use it to manage your project dependencies.\n\nYou don't need to get into the module bundlers and build tools just yet. Just make sure that you are able to use the dependencies installed in the `node_modules` folder using simple link and script tags in your HTML.\n\nRegarding projects, here are a few ideas that you can try:\n\n*   Create a simple webpage that shows the current time of user. You can use [dayjs](https://day.js.org/) to get the current time and display it on the page. Here is the [sample design for homepage](https://i.imgur.com/yGIMGkr.png).\n*   Install the [micromodal](https://micromodal.vercel.app/#introduction) library. Create a button on the page clicking which should open a modal and let the user select a timezone from a dropdown. Once the user selects a timezone, the modal should close and the time on the page should be updated to show the time in the selected timezone. Here is the [sample design for the modal](https://imgur.com/a/vFY6Sdl).",
+    "links": []
+  },
+  "CVCqdPkq_hGQfI8EEi5RC": {
+    "title": "Tailwind CSS",
+    "description": "CSS Framework that provides atomic CSS classes to help you style components e.g. `flex`, `pt-4`, `text-center` and `rotate-90` that can be composed to build any design, directly in your markup.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Tailwind Website",
+        "url": "https://tailwindcss.com",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Tailwind CSS",
+        "url": "https://app.daily.dev/tags/tailwind-css?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Tailwind CSS Full Course for Beginners",
+        "url": "https://www.youtube.com/watch?v=lCxcTsOHrjo",
+        "type": "video"
+      },
+      {
+        "title": "Tailwind CSS Crash Course",
+        "url": "https://www.youtube.com/watch?v=UBOj6rqRUME",
+        "type": "video"
+      },
+      {
+        "title": "Should You Use Tailwind CSS?",
+        "url": "https://www.youtube.com/watch?v=hdGsFpZ0J2E",
+        "type": "video"
+      },
+      {
+        "title": "Official Screencasts",
+        "url": "https://www.youtube.com/c/TailwindLabs/videos",
+        "type": "video"
+      }
+    ]
+  },
+  "khoUtTUxdf8udAzN9_CAb": {
+    "title": "React",
+    "description": "React is the most popular front-end JavaScript library for building user interfaces. React can also render on the server using Node and power mobile apps using React Native.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Visit Dedicated React Roadmap",
+        "url": "https://roadmap.sh/react",
+        "type": "article"
+      },
+      {
+        "title": "React Website",
+        "url": "https://react.dev/",
+        "type": "article"
+      },
+      {
+        "title": "Official Getting Started",
+        "url": "https://react.dev/learn/tutorial-tic-tac-toe",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about React",
+        "url": "https://app.daily.dev/tags/react?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "React JS Course for Beginners",
+        "url": "https://www.youtube.com/watch?v=nTeuhbP7wdE",
+        "type": "video"
+      },
+      {
+        "title": "React Course - Beginners Tutorial for React",
+        "url": "https://www.youtube.com/watch?v=bMknfKXIFA8",
+        "type": "video"
+      },
+      {
+        "title": "Understanding Reacts UI Rendering Process",
+        "url": "https://www.youtube.com/watch?v=i793Qm6kv3U",
+        "type": "video"
+      }
+    ]
+  },
+  "zFGWxgLPcZoW7KIzlnSV9": {
+    "title": "Checkpoint - Collaborative Work",
+    "description": "Now that you have learnt git and GitHub you should be ready to work with others. You should now setup your GitHub profile and push all the projects that you have built so far to your GitHub profile. Here are some of my recommendations for your GitHub profile:\n\n*   Keep the repository names lowercase and use hyphens to separate words e.g. `todo-app` instead of `TodoApp` or `Todo-App`.\n*   Add a `README.md` file to each repository that you create. This file should contain a description of the project. Put some effort into the readme and make sure it clearly details what the project is about and how anyone can run it locally.\n*   Add snapshots of your project to the readme file so that anyone can see what the project looks like without having to run it locally.\n*   Add a `LICENSE` file to each repository that you create. This file should contain the license that you want to use for the project. You can use [choosealicense.com](https://choosealicense.com/) to help you choose a license.\n\nYou can have a look at [my GitHub profile](https://github.com/kamranahmedse) and see how I have structured my repositories and how [some of my readme files look like](https://github.com/kamranahmedse/aws-cost-cli).",
+    "links": []
+  },
+  "7JU1cVggMDoZUV-adGsf-": {
+    "title": "Checkpoint - Frontend Apps",
+    "description": "At this point you should be able to build a complete frontend application including:\n\n*   Structuring your webpages with HTML\n*   Styling your webpages with CSS\n*   Adding interactivity to your webpages with JavaScript\n*   Using the DOM API to manipulate your webpages\n*   Using the Fetch API to make HTTP requests\n*   Understand promises and use `async`/`await` syntax to write asynchronous code\n*   Installing and using external libraries with npm\n*   Version controlling your code with Git\n*   Pushing your code to GitHub\n\nIf you decided to skip React and Tailwind for now, that is fine also but you should be able to build a complete frontend application using vanilla HTML, CSS, and JavaScript. However, keep in mind that the modern frontend applications are mostly built with frameworks like React, Vue, and Angular. So, you should learn at least one of them at any point of time.\n\nThis marks the end of frontend basics that you needed, we will now be moving to the backend development. While you continue with the backend development, know that there is more to frontend development and remember to checkout the [frontend roadmap](/frontend) later in your journey.",
+    "links": []
+  },
+  "_aA6Hp4KkgJeptqo8oKTg": {
+    "title": "Node.js",
+    "description": "Node.js is an open-source and cross-platform JavaScript runtime environment. It is a popular tool for almost any kind of project! Node.js runs the V8 JavaScript engine, Google Chrome's core, outside the browser. This allows Node.js to be very performant. A Node.js app runs in a single process, without creating a new thread for every request. Node.js provides a set of asynchronous I/O primitives in its standard library that prevent JavaScript code from blocking and generally, libraries in Node.js are written using non-blocking paradigms, making blocking behavior the exception rather than the norm.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Official Website",
+        "url": "https://nodejs.org/en/about/",
+        "type": "article"
+      },
+      {
+        "title": "Learn Node.js Official Website",
+        "url": "https://nodejs.org/en/learn/getting-started/introduction-to-nodejs",
+        "type": "article"
+      },
+      {
+        "title": "Node.JS Introduction",
+        "url": "https://www.w3schools.com/nodejs/nodejs_intro.asp",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Node.js",
+        "url": "https://app.daily.dev/tags/nodejs?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Node.js and Express.js Full Course",
+        "url": "https://www.youtube.com/watch?v=Oe421EPjeBE",
+        "type": "video"
+      }
+    ]
+  },
+  "JGu0TKwAw-ieiG92BytYI": {
+    "title": "Checkpoint — CLI Apps",
+    "description": "At this point you should be able to build CLI applications using Node.js or whatever backend programming language you picked.\n\nYou should be able to build a CLI application that can:\n\n*   Read and write files\n*   Parse command line arguments\n*   Make HTTP requests\n*   Parse JSON\n*   Use a third-party library (e.g. a library for parsing CSV files)\n*   Use a third-party API\n\nHere are some ideas for CLI applications you can build:\n\n*   Create a CLI application that takes a URL and a CSS selector arguments and prints the text content of the element that matches the selector. **Hint** you can use [cheerio](https://github.com/cheeriojs/cheerio)\n*   An application that optionally takes two dates and prints the most starred GitHub projects in that date range. **Hint** you can use [GitHub's search API](https://developer.github.com/v3/search/#search-repositories)\n*   Bulk rename files in a directory. **Hint** you can use [fs](https://nodejs.org/api/fs.html) and [path](https://nodejs.org/api/path.html)\n*   Write a CLI application that takes a path as input and compresses all the images in that directory. It should accept an option for output path; if the output path is not given it should compress images in place otherwise write the compressed images to the output path. **Hint** you can use [sharp](https://github.com/lovell/sharp).",
+    "links": []
+  },
+  "vmHbWdmMHF53otXIrqzRV": {
+    "title": "RESTful APIs",
+    "description": "REST, or REpresentational State Transfer, is an architectural style for providing standards between computer systems on the web, making it easier for systems to communicate with each other.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "What is a REST API?",
+        "url": "https://www.redhat.com/en/topics/api/what-is-a-rest-api",
+        "type": "article"
+      },
+      {
+        "title": "Roy Fieldings dissertation chapter, Representational State Transfer (REST)",
+        "url": "https://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm",
+        "type": "article"
+      },
+      {
+        "title": "Learn REST: A RESTful Tutorial",
+        "url": "https://restapitutorial.com/",
+        "type": "article"
+      }
+    ]
+  },
+  "3EtGLO6cwkLc1-o9gwFNk": {
+    "title": "Checkpoint — Simple CRUD Apps",
+    "description": "**CRUD** stands for **Create, Read, Update, and Delete**. These are the four basic operations you can perform on any data when working with web applications, databases, and APIs.\n\nNow that you know about programming language and the databases, you should be able to build a simple CLI application that interacts with database. We haven't talked about the APIs yet but you don't need an API to practice CRUD operations. Here are some of the CLI applications you can build to practice CRUD operations:\n\n*   A simple todo list application for the CLI with the following options:\n    *   `--new` to add a new todo item\n    *   `--list [all|pending|done]` to list the todo items\n    *   `--done [id]` to update a todo item\n    *   `--delete [id]` to delete a todo item\n    *   `--help` to list all the available options\n    *   `--version` to print the version of the application",
+    "links": []
+  },
+  "vHojhJYjiN0IwruEqi1Dv": {
+    "title": "JWT Auth",
+    "description": "JWT stands for JSON Web Token is a token-based encryption open standard/methodology that is used to transfer information securely as a JSON object. Clients and Servers use JWT to securely share information, with the JWT containing encoded JSON objects and claims. JWT tokens are designed to be compact, safe to use within URLs, and ideal for SSO contexts.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "jwt.io Website",
+        "url": "https://jwt.io/",
+        "type": "article"
+      },
+      {
+        "title": "Introduction to JSON Web Tokens",
+        "url": "https://jwt.io/introduction",
+        "type": "article"
+      },
+      {
+        "title": "What is JWT?",
+        "url": "https://www.akana.com/blog/what-is-jwt",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about JWT",
+        "url": "https://app.daily.dev/tags/jwt?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "What Is JWT and Why Should You Use JWT",
+        "url": "https://www.youtube.com/watch?v=7Q17ubqLfaM",
+        "type": "video"
+      },
+      {
+        "title": "What is JWT? JSON Web Token Explained",
+        "url": "https://www.youtube.com/watch?v=926mknSW9Lo",
+        "type": "video"
+      },
+      {
+        "title": "JWT Authentication Tutorial - Node.js",
+        "url": "https://www.youtube.com/watch?v=mbsmsi7l3r4",
+        "type": "video"
+      }
+    ]
+  },
+  "Onfd7Sl8LG2sjh2aQY7gb": {
+    "title": "Redis",
+    "description": "Redis is an open source (BSD licensed), in-memory **data structure store** used as a database, cache, message broker, and streaming engine. Redis provides data structures such as [strings](https://redis.io/topics/data-types-intro#strings), [hashes](https://redis.io/topics/data-types-intro#hashes), [lists](https://redis.io/topics/data-types-intro#lists), [sets](https://redis.io/topics/data-types-intro#sets), [sorted sets](https://redis.io/topics/data-types-intro#sorted-sets) with range queries, [bitmaps](https://redis.io/topics/data-types-intro#bitmaps), [hyperloglogs](https://redis.io/topics/data-types-intro#hyperloglogs), [geospatial indexes](https://redis.io/commands/geoadd), and [streams](https://redis.io/topics/streams-intro). Redis has built-in [replication](https://redis.io/topics/replication), [Lua scripting](https://redis.io/commands/eval), [LRU eviction](https://redis.io/topics/lru-cache), [transactions](https://redis.io/topics/transactions), and different levels of [on-disk persistence](https://redis.io/topics/persistence), and provides high availability via [Redis Sentinel](https://redis.io/topics/sentinel) and automatic partitioning with [Redis Cluster](https://redis.io/topics/cluster-tutorial).\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Redis Website",
+        "url": "https://redis.io/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Redis",
+        "url": "https://app.daily.dev/tags/redis?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Redis in 100 Seconds",
+        "url": "https://www.youtube.com/watch?v=G1rOthIU-uo",
+        "type": "video"
+      },
+      {
+        "title": "Redis Caching in Node.js",
+        "url": "https://www.youtube.com/watch?v=oaJq1mQ3dFI",
+        "type": "video"
+      }
+    ]
+  },
+  "SHTSvMDqI7X1_ZT7-m--n": {
+    "title": "Linux Basics",
+    "description": "Knowledge of UNIX is a must for almost all kind of development as most of the codes that you write is most likely going to be finally deployed on a UNIX/Linux machine. Linux has been the backbone of the free and open source software movement, providing a simple and elegant operating system for almost all your needs.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Coursera - Unix Courses",
+        "url": "https://www.coursera.org/courses?query=unix",
+        "type": "course"
+      },
+      {
+        "title": "Linux Basics",
+        "url": "https://dev.to/rudrakshi99/linux-basics-2onj",
+        "type": "article"
+      },
+      {
+        "title": "Unix / Linux Tutorial",
+        "url": "https://www.tutorialspoint.com/unix/index.htm",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Linux",
+        "url": "https://app.daily.dev/tags/linux?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Linux Operating System - Crash Course",
+        "url": "https://www.youtube.com/watch?v=ROjZy1WbCIA",
+        "type": "video"
+      }
+    ]
+  },
+  "v4NF25lJElAtkU0Rm6Fob": {
+    "title": "Checkpoint — Complete App",
+    "description": "At this point, you should have everything that you need to build a complete application that:\n\n*   Has a responsive frontend that users can interact with\n*   Has a backend API that is secured with JWT authentication\n*   Has a database that stores data\n\nAt this point you should practice building as much as you can on your own to solidify your knowledge. If you need inspiration, here are some ideas:\n\n*   Build a simple blogging application where users can register, login, setup their blog and write posts.\n*   A single page site builder where users can pick a template, modify it and publish it. **Hint** you will need filesystem to store the design templates. Template files will have placeholders that you will need to replace with user data.\n*   Build a simple e-commerce application which will have two types of users i.e. **Sellers** who can: Register as Seller, Login, Setup their store, Add products, Edit products, Delete products, View Received Orders, Update Order Status (Pending, Shipped, Delivered), **Buyers** who can register, Login, Browse products by all sellers, Add products to cart, Checkout, View order history, View order status, Cancel order, View seller profile, View seller products\n\nThese are just some ideas to get you started. You can build anything you want. The goal is to practice building a complete application from scratch.",
+    "links": []
+  },
+  "cUOfvOlQ_0Uu1VX3i67kJ": {
+    "title": "Basic AWS Services",
+    "description": "AWS has several services but you don't need to know all of them. Some common ones that you can start with are EC2, VPN, S3, Route 53, and SES.\n\nHere are some of the resources to get you started:",
+    "links": [
+      {
+        "title": "Up and Running with AWS VPC",
+        "url": "https://cs.fyi/guide/up-and-running-with-aws-vpc",
+        "type": "article"
+      },
+      {
+        "title": "Up and Running with AWS EC2",
+        "url": "https://cs.fyi/guide/up-and-running-with-aws-ec2",
+        "type": "article"
+      },
+      {
+        "title": "VPC Basics",
+        "url": "https://cloudcasts.io/course/vpc-basics",
+        "type": "article"
+      },
+      {
+        "title": "EC2 Essentials",
+        "url": "https://cloudcasts.io/course/ec2-essentials",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about AWS",
+        "url": "https://app.daily.dev/tags/aws?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Deploy Node App on AWS EC2",
+        "url": "https://youtu.be/oHAQ3TzUTro",
+        "type": "video"
+      },
+      {
+        "title": "AWS VPC & Subnets For Beginners",
+        "url": "https://youtu.be/TUTqYEZZUdc",
+        "type": "video"
+      },
+      {
+        "title": "Sam Meech-Ward's AWS Videos",
+        "url": "https://www.youtube.com/playlist?list=PL0X6fGhFFNTcU-_MCPe9dkH6sqmgfhy_M",
+        "type": "video"
+      },
+      {
+        "title": "DNS with AWS Route 53",
+        "url": "https://www.youtube.com/watch?v=yRIY7BJohfo",
+        "type": "video"
+      },
+      {
+        "title": "Upload Images to S3 from Node Back End",
+        "url": "https://www.youtube.com/watch?v=NZElg91l_ms",
+        "type": "video"
+      },
+      {
+        "title": "S3 Bucket Hosting a Static Website",
+        "url": "https://www.youtube.com/watch?v=RoY3ekCCxKc&list=PL0X6fGhFFNTcU-_MCPe9dkH6sqmgfhy_M",
+        "type": "video"
+      }
+    ]
+  },
+  "6oBIxYj8WPcUHidQ99tus": {
+    "title": "EC2",
+    "description": "Amazon Elastic Compute Cloud (EC2) is a web service that provides resizable compute capacity in the form of virtual servers, known as instances. With EC2, you can quickly scale your infrastructure up or down as your computing requirements change. This service effectively reduces the time required to obtain and boot new server instances, allowing you to easily adjust capacity according to the needs of your application.",
+    "links": [
+      {
+        "title": "Up and Running with AWS EC2",
+        "url": "https://cs.fyi/guide/up-and-running-with-aws-ec2",
+        "type": "article"
+      },
+      {
+        "title": "EC2 Essentials",
+        "url": "https://cloudcasts.io/course/ec2-essentials",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about AWS EC2",
+        "url": "https://app.daily.dev/tags/aws-ec2?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Deploy Node App on AWS EC2",
+        "url": "https://youtu.be/oHAQ3TzUTro",
+        "type": "video"
+      }
+    ]
+  },
+  "QtL-bLKtWIdH00K6k_PdC": {
+    "title": "VPC",
+    "description": "VPC stands for **Virtual Private Cloud** and is an essential service provided by AWS that allows you to create a private, isolated section within the AWS cloud, where you can define your own virtual network. It offers a more secure and controlled environment, enabling you to easily launch and manage your resources within your personal network.",
+    "links": [
+      {
+        "title": "Up and Running with AWS VPC",
+        "url": "https://cs.fyi/guide/up-and-running-with-aws-vpc",
+        "type": "article"
+      },
+      {
+        "title": "VPC Basics",
+        "url": "https://cloudcasts.io/course/vpc-basics",
+        "type": "article"
+      },
+      {
+        "title": "AWS VPC & Subnets For Beginners",
+        "url": "https://youtu.be/TUTqYEZZUdc",
+        "type": "video"
+      }
+    ]
+  },
+  "5zyYpu9cyuTFwQCjTbHpS": {
+    "title": "Route53",
+    "description": "[Route53](https://aws.amazon.com/route53/) is AWS's Domain Name System (DNS) service that plays a critical role in connecting user requests to your web application or other resources within your infrastructure. With Route53, you can easily manage domains, redirect traffic, and configure domain-related settings. It has several advantages, including high availability, low latency, and integration with other AWS resources.",
+    "links": [
+      {
+        "title": "Amazon Route 53",
+        "url": "https://www.youtube.com/watch?v=RGWgfhZByAI",
+        "type": "video"
+      },
+      {
+        "title": "AWS Route 53 Domain Name",
+        "url": "https://www.youtube.com/watch?v=jDz4j_kkyLA",
+        "type": "video"
+      },
+      {
+        "title": "DNS with AWS Route 53",
+        "url": "https://www.youtube.com/watch?v=yRIY7BJohfo&t=2s",
+        "type": "video"
+      }
+    ]
+  },
+  "B-cphY7Imnv6JBMujVIF7": {
+    "title": "SES",
+    "description": "Amazon SES (Simple Email Service) is a scalable, flexible, and cost-effective cloud-based email service that is specifically designed for developers, marketers, and businesses to send and receive marketing, transactional, and notification emails. SES is useful, especially when you need to send a large volume of emails, as it offers high deliverability, reliability, and ease of use.",
+    "links": [
+      {
+        "title": "Contact Form Submission With AWS SES",
+        "url": "https://www.youtube.com/watch?v=HiHflLTqiwU",
+        "type": "video"
+      }
+    ]
+  },
+  "n2Xp_ijJ2OS8xhE7xMWxk": {
+    "title": "S3",
+    "description": "S3 is a service that allows you to store files in the cloud. It's a simple service that you can use to store files and serve them to your users.",
+    "links": [
+      {
+        "title": "Explore top posts about AWS S3",
+        "url": "https://app.daily.dev/tags/aws-s3?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Upload Images to S3 from Node Back End",
+        "url": "https://www.youtube.com/watch?v=NZElg91l_ms",
+        "type": "video"
+      },
+      {
+        "title": "S3 Bucket Hosting a Static Website",
+        "url": "https://www.youtube.com/watch?v=RoY3ekCCxKc&list=PL0X6fGhFFNTcU-_MCPe9dkH6sqmgfhy_M",
+        "type": "video"
+      }
+    ]
+  },
+  "y1SFX7uvWaCy4OYBnECLu": {
+    "title": "Monit",
+    "description": "When it comes to monitoring the health of your applications, there are several different options available. My favorite monitoring stack is Prometheus and Grafana, but it can be a bit overwhelming to set up and configure. If you're looking for a simpler solution, **Monit** is a great alternative that can be utilized to monitor and manage system resources such as services, processes, files, directories, devices, and network connections, making your application more reliable and resilient to issues like crashes, unresponsiveness, or resource exhaustion.\n\nSome of the key features of Monit are:\n\n*   **Automatic Recovery:** Monit can automatically restart a service or process if it fails, making your application more resistant to unexpected issues.\n*   **Alert Notifications:** Monit can send email notifications when a problem is detected or when a certain condition is met, keeping you informed about the health of your application.\n*   **Event Logging:** All events detected by Monit are stored in a log for easy troubleshooting and analysis.\n*   **Resource Limit Monitoring:** Monit can monitor the resource utilization (CPU, memory, network, etc.) of a process or service and take action if a specific limit is exceeded.\n*   **Flexible Configuration:** Monit uses a simple, human-readable configuration syntax that allows you to tailor its behavior to your needs.\n*   **Web Interface:** Monit provides a built-in web interface for remotely monitoring your application's status and manage services.\n\nHave a look at the following resources to learn more about Monit:",
+    "links": [
+      {
+        "title": "Monit documentation",
+        "url": "https://mmonit.com/monit/documentation/",
+        "type": "article"
+      },
+      {
+        "title": "Monit - Opensource Self Healing Server Monitoring",
+        "url": "https://www.youtube.com/watch?v=3cA5lNje1Ow",
+        "type": "video"
+      }
+    ]
+  },
+  "HGhnbMg6jh6cAmUH4DtOx": {
+    "title": "PostgreSQL",
+    "description": "PostgreSQL, also known as Postgres, is a free and open-source relational database management system emphasizing extensibility and SQL compliance.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Visit Dedicated PostgreSQL DBA Roadmap",
+        "url": "https://roadmap.sh/postgresql-dba",
+        "type": "article"
+      },
+      {
+        "title": "Official Website",
+        "url": "https://www.postgresql.org/",
+        "type": "article"
+      },
+      {
+        "title": "Learn PostgreSQL - Full Tutorial for Beginners",
+        "url": "https://www.postgresqltutorial.com/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about PostgreSQL",
+        "url": "https://app.daily.dev/tags/postgresql?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Learn PostgreSQL Tutorial - Full Course for Beginners",
+        "url": "https://www.youtube.com/watch?v=qw--VYLpxG4",
+        "type": "video"
+      },
+      {
+        "title": "Postgres tutorial for Beginners",
+        "url": "https://www.youtube.com/watch?v=eMIxuk0nOkU",
+        "type": "video"
+      }
+    ]
+  },
+  "J2_IWAb1s9zZcxOY3NXm2": {
+    "title": "Checkpoint — Deployment",
+    "description": "Now that you know the basics of AWS, you should be able to deploy your application to AWS. You don't need to use all the AWS services, here is what you can probably get started with:\n\n*   Setup an EC2 instance using any AMI (e.g. latest version of Ubuntu)\n*   SSH into the EC2 instance using the key pair you created\n*   Install Node.js on the EC2 instance\n*   Install Git on the EC2 instance\n*   Clone your application from GitHub\n*   Install and configure database on the EC2 instance (e.g. PostgreSQL)\n*   Make sure that the security group of the EC2 instance allows HTTP and HTTPS traffic\n*   Try to access your application using the public IP address of the EC2 instance\n*   Purchase or setup a domain name using Route53 (or any other domain name provider) and point it to the public IP address of the EC2 instance\n*   Setup HTTPs using [certbot](https://roadmap.sh/guides/setup-and-auto-renew-ssl-certificates)\n*   And voilla! You have deployed your application to AWS!\n\nIf you get stuck, here is a video that shows how to deploy a Node.js application to AWS EC2:",
+    "links": [
+      {
+        "title": "Explore top posts about CI/CD",
+        "url": "https://app.daily.dev/tags/cicd?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Deploy Node App on AWS EC2",
+        "url": "https://youtu.be/oHAQ3TzUTro",
+        "type": "video"
+      }
+    ]
+  },
+  "863KMXcFJzInvTp_-Ldmz": {
+    "title": "GitHub Actions",
+    "description": "GitHub Actions is a workflow automation tool provided by GitHub that can be used to automate various tasks in the app development process.",
+    "links": [
+      {
+        "title": "Github Actions",
+        "url": "https://github.com/features/actions",
+        "type": "opensource"
+      },
+      {
+        "title": "Github Actions Documentation",
+        "url": "https://docs.github.com/en/actions",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about GitHub",
+        "url": "https://app.daily.dev/tags/github?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "5 Ways to DevOps-ify your App",
+        "url": "https://www.youtube.com/watch?v=eB0nUzAI7M8",
+        "type": "video"
+      },
+      {
+        "title": "DevOps CI/CD Explained in 100 Seconds",
+        "url": "https://www.youtube.com/watch?v=scEDHsr3APg",
+        "type": "video"
+      }
+    ]
+  },
+  "NQmEl27eBPYhivcXdOEz3": {
+    "title": "Checkpoint — Monitoring",
+    "description": "You should now implement monitoring and autorestarts for your application using monit. Regarding autorestarts, you can also use [pm2](https://pm2.keymetrics.io/).\n\nHere are some of the monitors you should implement for the application.\n\n*   CPU Usage\n*   Memory Usage\n*   Disk Usage\n*   Network Usage\n*   Service Availability\n*   Process Availability\n\nMonit comes with existing configurations for many services. You can find them in `/etc/monit/conf-available`. You can copy them (and modify if required) to `/etc/monit/conf-enabled` to enable them.",
+    "links": []
+  },
+  "rFXupYpUFfp7vZO8zh614": {
+    "title": "Ansible",
+    "description": "Ansible is an open-source configuration management, application deployment and provisioning tool that uses its own declarative language in YAML. Ansible is agentless, meaning you only need remote connections via SSH or Windows Remote Management via Powershell in order to function\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Ansible Website",
+        "url": "https://www.ansible.com/",
+        "type": "article"
+      },
+      {
+        "title": "Official Documentation",
+        "url": "https://docs.ansible.com/",
+        "type": "article"
+      },
+      {
+        "title": "Ansible Getting Started Guide",
+        "url": "https://www.ansible.com/resources/get-started",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Ansible",
+        "url": "https://app.daily.dev/tags/ansible?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Ansible Full Course for Beginners",
+        "url": "https://www.youtube.com/watch?v=9Ua2b06oAr4",
+        "type": "video"
+      }
+    ]
+  },
+  "liaY1GnlOateB_ZKBjNpY": {
+    "title": "Checkpoint — CI / CD",
+    "description": "Now that you have the infrastructure setup, it's time to automate the deployment process. This is where CI / CD comes in. If you don't know what CI/CD are, you should watch [DevOps CI/CD Explained in 100 Seconds](https://www.youtube.com/watch?v=scEDHsr3APg).\n\nThe next step at this point is to implement CI/CD for your application using GitHub actions. Setup a GitHub action that, whenever you push to master, will automatically:\n\n*   Run your tests (ignore this step if you haven't learnt it yet)\n*   Deploy your application to AWS\n\nRegarding the deployment to AWS you can use `rsync` to copy the files to the server. Here's a [sample GitHub workflow](https://gist.github.com/kamranahmedse/1e94b412006040f38e24b9443b2da41a) using `rsync`.",
+    "links": []
+  },
+  "2kKHuQZScu7hCDgQWxl5u": {
+    "title": "Terraform",
+    "description": "Terraform is an extremely popular open source Infrastructure as Code (IaC) tool that can be used with many different cloud and service provider APIs. Terraform focuses on an immutable approach to infrastructure, with a terraform state file center to tracking the status of your real world infrastructure.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Terraform Website",
+        "url": "https://www.terraform.io/",
+        "type": "article"
+      },
+      {
+        "title": "Terraform Documentation",
+        "url": "https://www.terraform.io/docs",
+        "type": "article"
+      },
+      {
+        "title": "Terraform Tutorials",
+        "url": "https://learn.hashicorp.com/terraform",
+        "type": "article"
+      },
+      {
+        "title": "Terraform CDK Website",
+        "url": "https://www.terraform.io/cdktf",
+        "type": "article"
+      },
+      {
+        "title": "What is the CDKTF?",
+        "url": "https://www.terraform.io/cdktf/concepts/cdktf-architecture",
+        "type": "article"
+      },
+      {
+        "title": "CDKTF Getting Started Guide",
+        "url": "https://learn.hashicorp.com/tutorials/terraform/cdktf-install?in=terraform/cdktf",
+        "type": "article"
+      },
+      {
+        "title": "CDKTF Examples",
+        "url": "https://www.terraform.io/cdktf/examples",
+        "type": "article"
+      },
+      {
+        "title": "How to Scale Your Terraform Infrastructure",
+        "url": "https://thenewstack.io/how-to-scale-your-terraform-infrastructure/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Terraform",
+        "url": "https://app.daily.dev/tags/terraform?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Intro to Terraform Video",
+        "url": "https://www.youtube.com/watch?v=h970ZBgKINg&ab_channel=HashiCorp",
+        "type": "video"
+      }
+    ]
+  },
+  "sO_9-l4FECbaqiaFnyeXO": {
+    "title": "Checkpoint — Automation",
+    "description": "Now that you have learnt ansible, you can use it to automate the deployment of your application.\n\nA task for you at this point would be to automate the steps that you manually performed earlier when setting up the EC2 instance i.e. SSH into the server, install Node.js, Git, PostgreSQL, Running the application etc. Write an ansible playbook that automates these and see if you can spin up a new EC2 instance without SSHing into it and manually installing all the dependencies.",
+    "links": []
+  },
+  "YVMyHFSCVF-GgXydq-SFJ": {
+    "title": "Checkpoint — Infrastructure",
+    "description": "If you remember, earlier in the roadmap, you manually logged into the AWS console and had to setup the services. Now that you know terraform, go ahead and automate the process of creating the infrastructure for your application using terraform and with that your deployments will be fully automated i.e., you should have:\n\n*   Infrastructure setup using terraform\n*   Provisioning using Ansible\n*   CI/CD using GitHub Actions\n*   Monitoring using Monit\n\nAnd that is it! You have successfully completed the roadmap and are now a full-stack developer. Congratulations! 🎉\n\nWhat's next?\n------------\n\nGo ahead and build something cool! Share your learnings with the community and help others learn as well. If you have any questions, feel free to join our [discord server](https://roadmap.sh/discord) and ask away!",
+    "links": []
+  }
+}

public/roadmap-content/game-developer.json

@@ -0,0 +1,905 @@
+{
+  "rQArtuVKGVgLn_fw9yO3b": {
+    "title": "Client Side Development",
+    "description": "In game development, the term \"Client Side\" refers to all the operations and activities that occur on the player's machine, which could be a console, computer, or even a phone. The client side is responsible for rendering graphics, handling input from the user and sometimes processing game logic. This is in contrast to the server-side operations, which involve handling multiplayer connections and synchronizing game states among multiple clients. On the client side, developers need to ensure performance optimization, smooth UI/UX, quick load times, and security to provide an engaging, lag-free gaming experience. Security is also crucial to prevent cheating in multiplayer games, which can be tackled through measures like Data obfuscation and encryption.",
+    "links": []
+  },
+  "m1wX27XBWKXZcTMH2U1xp": {
+    "title": "Game Mathematics",
+    "description": "\"Game Mathematics\" is a critical aspect of game development that deals with the use of mathematical concepts to create and control game mechanics. This involves areas such as geometry for 3D modelling, logic for game rules, algebra for scoring systems, and trigonometry for movements or trajectories. Understanding game mathematics enables developers to implement features like physics simulation, AI behaviours, and procedural generation. Advanced topics include complex calculations for graphics (e.g., shaders, lighting) and calculus for continuous animation or advanced physics. The mathematical complexity depends on the game's demands, but a solid foundation is crucial for any game developer.",
+    "links": []
+  },
+  "grRf-MmaXimDB4iODOV47": {
+    "title": "Linear Algebra",
+    "description": "Linear Algebra is a vital field in Mathematics that is extensively used in game development. It revolves around vector spaces and the mathematical structures used therein, including matrices, determinants, vectors, eigenvalues, and eigenvectors, among others. In the context of game development, linear algebra is used mainly for computer graphics, physics, AI, and many more. It allows developers to work with spatial transformations, helping them manipulate and critically interact with the 3D space of the game. On a broader context, it is important in computer programming for algorithms, parallax shifting, polygonal modeling, collision detection, etc. From object movements, positional calculations, game physics, to creating dynamism in games, linear algebra is key.",
+    "links": [
+      {
+        "title": "Explore top posts about Math",
+        "url": "https://app.daily.dev/tags/math?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Linear Algebra full course by Kimberly Brehm",
+        "url": "https://youtube.com/playlist?list=PLl-gb0E4MII03hiCrZa7YqxUMEeEPmZqK&si=_r0WDwh94NKJbs_R",
+        "type": "video"
+      }
+    ]
+  },
+  "yLEyh5XJ3sl8eHD-PoSvJ": {
+    "title": "Vector",
+    "description": "`Vector` in game development is a mathematical concept and an integral part of game physics. It represents a quantity that has both magnitude and direction. A vector can be used to represent different elements in a game like positions, velocities, accelerations, or directions. In 3D games, it's commonly used to define 3D coordinates (x, y, z). For example, if you have a character in a game and you want to move it up, you'd apply a vector that points upward. Hence, understanding how to manipulate vectors is a fundamental skill in game development.",
+    "links": [
+      {
+        "title": "Introduction to Vectors (By Sebastian Lague)",
+        "url": "https://youtu.be/m7VY1T6f8Ak?feature=shared",
+        "type": "video"
+      }
+    ]
+  },
+  "Kg6Mg9ieUUGXWX9Lai7B0": {
+    "title": "Matrix",
+    "description": "In game development, a **matrix** is a fundamental part of game mathematics. It's a grid of numbers arranged into rows and columns that's particularly important in 3D game development. These matrices are typically 4x4, meaning they contain 16 floating point numbers, and they're used extensively for transformations. They allow for the scaling, rotation, and translation (moving) of 3D vertices in space. With matrices, these transformations can be combined, and transformed vertices can be used to draw the replicas of 3D models into 2D screen space for rendering.",
+    "links": []
+  },
+  "XWxW2ZBw3LcQ4DRk4tgAG": {
+    "title": "Geometry",
+    "description": "Geometry in game development refers to the mathematical study used to define the spatial elements within a game. This is vital in determining how objects interact within a game's environment. Particularly, geometry is employed in various aspects like object rendering, collision detection, character movement, and the calculation of angles and distance. It allows developers to create the spatial parameters for a game, including object dimensions and orientations. Understanding the basics such as 2D vs 3D, polygons, vertices, meshes and more advanced topics such as vectors, matrices, quaternions etc. is crucial to this field.",
+    "links": []
+  },
+  "XABzEU9owCx9-zw1id9xU": {
+    "title": "Linear Transformation",
+    "description": "`Linear transformations` or `linear maps` are an important concept in mathematics, particularly in the fields of linear algebra and functional analysis. A linear transformation can be thought of as a transformation that preserves the operations of addition and scalar multiplication. In other words, a transformation T is linear if for every pair of vectors `x` and `y`, the equation T(x + y) = T(x) + T(y) holds true. Similarly, for any scalar `c` and any vector `x`, the equation T(cx)=cT(x) should also hold true. This property makes them very useful when dealing with systems of linear equations, matrices, and in many areas of computer graphics, including game development.",
+    "links": []
+  },
+  "r5TcXQsU9s4NlAQIPvZ3U": {
+    "title": "Affine Space",
+    "description": "In the context of game mathematics, an **Affine Space** is a fundamental concept you should understand. It is a geometric structure with properties related to both geometry and algebra. The significant aspect of an affine space is that it allows you to work more comfortably with points and vectors. While a vector space on its own focuses on vectors which have both magnitude and direction, it does not involve points. An affine space makes it easy to add vectors to points or subtract points from each other to get vectors. This concept proves extremely useful in the field of game development, particularly when dealing with graphical models, animations, and motion control.",
+    "links": []
+  },
+  "SkCreb6g4i-OFtJWhRYqO": {
+    "title": "Affine Transformation",
+    "description": "An **affine transformation**, in the context of game mathematics, is a function between affine spaces which preserves points, straight lines and planes. Also, sets of parallel lines remain parallel after an affine transformation. In video games, it's typically used for manipulating an object's position in 3D space. This operation allows game developers to perform multiple transformations such as translation (moving an object from one place to another), scaling (changing the size of an object), and rotation (spinning the object around a point). An important feature of affine transformation is that it preserves points uniqueness; if two points are distinct to start with, they remain distinct after transformation. It's important to note that these transformations are applied relative to an object's own coordinate system, not the world coordinate system.",
+    "links": []
+  },
+  "iIWEjpkNFBj4R5wQ0mcWY": {
+    "title": "Orientation",
+    "description": "In the context of game development, **Orientation** refers to the aspect or direction in which an object is pointed in a 3D space. To determine an object's orientation in 3D space, we typically use three angles namely: pitch, yaw, and roll collectively known as Euler's angles. **Pitch** is the rotation around the X-axis, **Yaw** around the Y-axis and **Roll** around the Z-axis. Alternatively, orientation can also be represented using a Quaternion. Quaternions have the advantage of avoiding a problem known as Gimbal lock (a loss of one degree of freedom in 3D space), present when using Euler's angles.",
+    "links": []
+  },
+  "zPs_LlDvkfxvvCrk5fXB2": {
+    "title": "Quaternion",
+    "description": "The **quaternion** is a complex number system that extends the concept of rotations in three dimensions. It involves four components: one real and three imaginary parts. Quaternions are used in game development for efficient and accurate calculations of rotations and orientation. They are particularly useful over other methods, such as Euler angles, due to their resistance to problems like Gimbal lock. Despite their complex nature, understanding and implementing quaternions can greatly enhance a game's 3D rotational mechanics and accuracy.",
+    "links": [
+      {
+        "title": "Understanding Quaternions",
+        "url": "https://www.3dgep.com/understanding-quaternions/",
+        "type": "article"
+      },
+      {
+        "title": "Unity docs - Quaternions",
+        "url": "https://docs.unity3d.com/ScriptReference/Quaternion.html",
+        "type": "article"
+      },
+      {
+        "title": "Quaternions and 3d rotation,explained interactively",
+        "url": "https://youtu.be/zjMuIxRvygQ?si=ANmFr5k8JMUzBCUC",
+        "type": "video"
+      }
+    ]
+  },
+  "L0J2kvveJNsmN9ueXhqKf": {
+    "title": "Euler Angle",
+    "description": "The **Euler angle** is a concept in mathematics and physics used to describe the orientation of a rigid body or a coordinate system in 3D space. It uses three angles, typically named as alpha (α), beta (β), and gamma (γ), and represents three sequential rotations around the axes of the original coordinate system. Euler angles can represent any rotation as a sequence of three elementary rotations. Keep in mind, however, that Euler angles are not unique, and different sequences of rotations can represent identical total effects. It's also noteworthy that Euler angles are prone to a problem known as gimbal lock, where the first and third axis align, causing a loss of a degree of freedom, and unpredictable behavior in particular orientations.",
+    "links": []
+  },
+  "YTkOF_33oL1ZkA-loc_DP": {
+    "title": "Curve",
+    "description": "Curve\n-----",
+    "links": []
+  },
+  "nTiHZXRh2j3_FsBotmlGf": {
+    "title": "Spline",
+    "description": "`Spline` is a mathematical function widely used in computer graphics for generating curves and surfaces. It connects two or more points through a smooth curve, often used in games for defining pathways, movement paths, object shapes, and flow control. Splines are not confined to two dimensions and can be extended to 3D or higher dimensions. Types of splines include `Linear`, `Cubic`, and `Bezier` splines. While linear splines generate straight lines between points, cubic and bezier splines provide more control and complexity with the addition of control points and handles. Developing a good understanding of splines and their usage can vastly improve the fluidity and visual aesthetics of a game.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "@Video@In-depth video about Splines by Freya Holmér",
+        "url": "https://youtu.be/jvPPXbo87ds?si=JX_G-gS81tOwQwjf",
+        "type": "article"
+      }
+    ]
+  },
+  "m4AuHjEBnHS0wyATG-I1Z": {
+    "title": "Hermite",
+    "description": "Hermite refers to Hermite interpolation, a fundamental technique in game development for executing smooth transitions. Essentially, Hermite interpolation is an application of polynomial mathematics, with two points applied as start/end (they're usually 3D positional vectors), and the tangents at these points controlling the curve's shape. The technique's name is derived from its inventor, Charles Hermite, a French mathematician. Hermite interpolation can be useful in different aspects of game development, such as creating smooth animations, camera paths, or motion patterns. Note, however, that while Hermite interpolation offers control over the start and end points of a sequence, it might not precisely predict the curve's full behavior.",
+    "links": []
+  },
+  "DUEEm9sAaZqSI-W-PFZ8f": {
+    "title": "Bezier",
+    "description": "`Bezier curves` are named after Pierre Bezier, a French engineer working at Renault, who used them in the 1960s for designing car bodies. A Bezier curve is defined by a set of control points with a minimum of two but no upper limit. The curve is calculated between the first and the last control point and does not pass through the controlling points, which only influence the direction of the curve. There are linear, quadratic, and cubic Bezier curves, but curves with more control points are also possible. They are widely used in computer graphics, animations, and are extensively used in vector images and tools to create shapes, texts, and objects.",
+    "links": []
+  },
+  "N9GoA3YvOaKwYjljj6NZv": {
+    "title": "Catmull-Rom",
+    "description": "The **Catmull-Rom** spline is a form of interpolation used in 2D and 3D graphics. Named after Edwin Catmull and Raphael Rom, it offers a simple way to smoothly move objects along a set of points or, in terms of graphics, to smoothly draw a curve connecting several points. It's a cubic interpolating spline, meaning it uses the cubic polynomial to compute coordinates. This makes Catmull-Rom ideal for creating smooth and natural curves in graphics and animation. It also has a feature called C1 continuity, ensuring the curve doesn't have any abrupt changes in direction. However, if not managed properly, it can create loops between points.",
+    "links": []
+  },
+  "5qfoD77wU4ETI7rUSy4Nc": {
+    "title": "Projection",
+    "description": "`Projection` in game mathematics often refers to the method by which three-dimensional images are transferred to a two-dimensional plane, typically a computer screen. There are two main types of projection in game development; `Orthographic Projection` and `Perspective Projection`. In the Orthographic Projection, objects maintain their size regardless of their distance from the camera. This is often used in 2D games or 3D games where perspective is not important. On the other hand, Perspective Projection mimics human eye perspective, where distant objects appear smaller. This method provides a more realistic rendering for 3D games. It's crucial to understand projection in game development because it governs how virtual 3D spaces and objects are displayed on 2D viewing platforms.",
+    "links": []
+  },
+  "LEJymJ2EaAW5FM5LgKW38": {
+    "title": "Perspective",
+    "description": "In game development, **Perspective** plays a significant role in creating a three-dimensional world on a two-dimensional space. It mimics the way our eyes perceive distance and depth, with objects appearing smaller as they go farther away. Essentially, this is achieved by projecting 3D co-ordinates on a virtual screen. Perspective projection is done in two types - one-point where only one axis displays a change in size with depth and two-point where both axis display a change. It creates more realistic views, enhancing game visualization and immersion. An important aspect is the player's viewpoint, which is the vanishing point where parallel lines converge in the distance.",
+    "links": []
+  },
+  "d6C1qFv-Tad3AtMBDLI6r": {
+    "title": "Orthogonal",
+    "description": "Orthogonal projection, or orthographic projection, is a type of parallelogram projection in game development where the lines of projection are perpendicular to the projection plane. This creates a view that is straight-on, essentially removing any form of perspective. Unlike perspective projection where objects further from the viewer appear smaller, objects in orthogonal projection remain the same size regardless of distance. The lack of perspective in orthogonal projection can be useful for specific types of games like platformers or strategy games. It is commonly used in CAD (Computer-Aided Design) and technical drawings as well.",
+    "links": []
+  },
+  "UTBnrQiZ6Bf96yJYIUf3b": {
+    "title": "Game Physics",
+    "description": "_Game physics_ is an integral part of game development that simulates the laws of physics in a virtual environment. This simulation brings realism into the game by defining how objects move, interact, and react to collisions and forces. Game physics ranges from how a character jumps or moves in a 2D or 3D space, to more complex mechanics such as fluid dynamics or ragdoll physics. Two main types of game physics are 'arcade physics', which are simpler and more abstract; and 'realistic physics', attempting to fully recreate real-life physics interactions. Implementing game physics requires a combination of mathematical knowledge and programming skills to integrate physics engines like Unity's PhysX and Unreal Engine's built-in physics tool.",
+    "links": []
+  },
+  "0D7KQlF-9ylmILTBBVxot": {
+    "title": "Dynamics",
+    "description": "**Dynamics** in game physics refers to the calculation and simulation of the movement and interaction of objects over time, taking into account properties such as mass, force, and velocity. Its purpose is to ensure the motion of game elements matches expectations in the real-world, or the specific conditions defined by the game designers. This typically includes topics like kinematics (velocity and acceleration), Newton's laws of motion, forces (like gravity or friction), and conservation laws (such as momentum or energy). This also involves solving equations of motions for the game objects, detecting collisions and resolving them. Dynamics, together with Statics (dealing with how forces balance on rigid bodies at rest), makes up the core of game physics simulation.",
+    "links": []
+  },
+  "HWtU4q-YPXxSi64t43VNF": {
+    "title": "Center of Mass",
+    "description": "The **center of mass** is a position defined relative to an object or system of objects. Typically denoted by the symbol (COM), it refers to the average position of all the parts of the system, weighted according to their masses. For instance, if you have a uniformly dense object, the center of mass would be in the geometric center of that object. In gaming, the center of mass of an object can have a significant impact on how the object behaves when forces are applied to it. This includes how the object moves in response to these forces, and can affect the realism of the physics simulations in a game.",
+    "links": []
+  },
+  "6E2mkXuAzoYnrT1SEIA16": {
+    "title": "Moment of Inertia",
+    "description": "The **moment of inertia**, also known as rotational inertia, is a measure of an object's resistance to changes to its rotation. In simpler terms, it's essentially how difficult it is to start or stop an object from spinning. It is determined by both the mass of an object and its distribution of mass around the axis of rotation. In the context of game development, the moment of inertia is crucial for creating realistic movements of characters, objects or vehicles within the game. This is particularly relevant in scenarios where the motion involves spinning or revolving entities. Calculating and applying these physics ensures a more immersive and believable gaming experience.",
+    "links": []
+  },
+  "ejZMnxZ0QrN-jBqo9Vrj8": {
+    "title": "Acceleration",
+    "description": "**Acceleration** refers to the rate of change in velocity per unit time. This physical concept is translated into game dynamics where it impacts the movement and speed of game characters or objects. For example, when a character starts moving, there is usually a slight delay before they reach their top speed, which then continues as long as the move button is held down. This is caused by acceleration. Conversely, when the button is released, the character doesn't stop instantly but slows down gradually - this is due to deceleration, which is negative acceleration. By mastering acceleration and deceleration, game developers can create more realistic and interesting movements for their characters.",
+    "links": []
+  },
+  "m2_wUW2VHMCXHnn5B91qr": {
+    "title": "Joints",
+    "description": "Joints in game development primarily refer to the connections between two objects, often used in the context of physics simulations and character animations. These might simulate the physics of real-world joints like hinges or springs. Developers can control various characteristics of joints such as their constraints, forces, and reactions. The different types come with various properties suitable for specific needs. For example, Fixed joints keep objects together, Hinge joints allow rotation around an axis, and Spring joints apply a force to keep objects apart.",
+    "links": []
+  },
+  "qduFRhmrzJ2sn0g7L-tza": {
+    "title": "Force",
+    "description": "**Force** is a vital concept in game development, especially when crafting physics in games. In the context of game physics, 'Force' is an influence that causes an object to undergo a certain change, either concerning its movement, direction, or geometrical construction. It's typically implemented in game engines, with part of the physics simulation that computes forces like gravity, friction, or custom forces defined by the developer. Incorporating forces gives a realistic feel to the game, allowing objects to interact naturally following the laws of physics. This is central in genres like racing games, sports games, and any game featuring physical interactions between objects. Remember that `F = ma`, the acceleration of an object is directly proportional to the force applied and inversely proportional to its mass. The balance and manipulation of these forces are integral to dynamic, immersive gameplay.",
+    "links": []
+  },
+  "egOcxFTQP7vPIGrxcieuk": {
+    "title": "Restitution",
+    "description": "In game development, **Restitution** is a property closely related to the physics of objects. Essentially, restitution represents the \"bounciness\" of an object or, in more scientific terms, the ratio of the final relative velocity to the initial relative velocity of two objects after a collision. In the context of game physics, when objects collide, restitution is used to calculate how much each object should bounce back or recoil. Restitution values typically fall between 0 and 1 where a value of 0 means an object will not bounce at all and a value of 1 refers to a perfectly elastic collision with no energy lost. Therefore, the higher the restitution value, the higher the bounce back of the object after a collision.",
+    "links": []
+  },
+  "Y7HYY5eq7OG42V9yQz0Q1": {
+    "title": "Angular Velocity",
+    "description": "Angular velocity, denoted by the symbol 'ω', is a measure of the rate of change of an angle per unit of time. In simpler terms, it corresponds to how quickly an object moves around a circle or rotates around a central point. Angular velocity is typically measured in radians per second (rad/s). If you think of an object moving in a circular path, the angular velocity would be the speed at which the angle changes as the object travels along the circumference of the object. Angular velocity is a vector quantity, implying it has both magnitude and direction. The direction of the angular velocity vector is perpendicular to the plane of rotation, following the right-hand rule. It plays a crucial role in game development, especially in physics simulation and character control.",
+    "links": []
+  },
+  "WzcmdW_fKHv3gwdBnvI0_": {
+    "title": "Buoyancy",
+    "description": "**Buoyancy** refers to a specific interaction in physics where an object submerged in fluid (such as a game character in water) experiences an upward force that counteracts the force of gravity. This makes the object either float or appear lighter. In game development, implementing buoyancy can enhance realism particularly in games that involve water-based activities or environments. Buoyancy can be manipulated through adjustments in density and volume to create various effects - from making heavy objects float to sinking light ones. Calculating it typically requires approximating the object to a sphere or another simple geometric shape, and using this in Archimedes' Principle. This principle states that buoyant force equals the weight of the fluid that the object displaces. In the realm of video games, programming buoyancy can involve complex physics equations and careful testing to achieve a balance between realism and playability.",
+    "links": []
+  },
+  "Z_U6abGV_wVkTGZ2LVkFK": {
+    "title": "Linear Velocity",
+    "description": "**Linear Velocity** is a fundamental concept in physics that is extensively used in game development. It refers to the rate of change of an object's position with respect to a frame of reference. It's calculated by dividing the change in position by the change in time, often represented with the vector 'v'. In game development, an object's linear velocity can be manipulated to control its speed and direction. This is especially important in the development of physics simulations or movement-dependent gameplay elements. For instance, it can be used to make a character run or drive, or to throw an object at different speeds and directions.",
+    "links": []
+  },
+  "Hz9R4YGYtD0jAur8rYist": {
+    "title": "Friction",
+    "description": "`Friction` is a crucial concept in game dynamics. In the context of games, it's typically used to slow down or impede movement, providing a realistic feel to characters or objects movement. For example, when a player's character runs on a smooth surface as compared to a rough one, friction influences the speed and control of that character. It can be seen in how cars skid on icy surfaces, how walking speed changes depending on the terrain, or how a ball rolls and eventually slows. The equation to compute friction is usually `f = μN`, where `f` is the force of friction, `μ` is the coefficient of friction (which depends on the two surfaces interacting), and `N` is the normal force (which is generally the weight of the object). You can adjust the coefficient of friction in a game to have different effects depending upon the desired outcome.",
+    "links": [
+      {
+        "title": "Friction",
+        "url": "https://youtu.be/t1HWIoDUWXg?si=FmFsIGTSHpLS72vp",
+        "type": "video"
+      }
+    ]
+  },
+  "AdOfOJtLtNgDwuABb6orE": {
+    "title": "Collision Detection",
+    "description": "**Collision Detection** is a critical aspect in game physics that handles the computer’s ability to calculate and respond when two or more objects come into contact in a game environment. This is vital to ensure objects interact realistically, don't pass through each other, and impact the game world in intended ways. Techniques for collision detection can vary based on the complexity required by the game. Simple methods may involve bounding boxes or spheres that encapsulate objects. When these spheres or boxes overlap, a collision is assumed. More complex methods consider the object's shape and volume for precise detection. Several libraries and game engines offer built-in support for collision detection, making it easier for developers to implement in their games.",
+    "links": []
+  },
+  "SuemqQuiePab0Qpm2EGy9": {
+    "title": "Narrow Phase",
+    "description": "The **Narrow Phase** of collision detection is a process that dives deeply into detailed collision checks for pairs of objects that are already found to be potentially colliding during the broad phase. Narrow phase is essentially a fine-tuning process. Upon positive detection from the broad phase, it identifies the precise points of collision between the two objects, and it may involve more detailed shape representations and more expensive algorithms. It might also calculate additional information necessary for the physics simulation (like the exact time of impact and contact normals). The usual methods used for this phase involve bounding box, bounding sphere or separating axis theorem. However, the method can vary depending on the complexity of shapes of objects and the specific needs of the game.",
+    "links": []
+  },
+  "AKd2UpITqBZV7cZszSRps": {
+    "title": "Broad Phase",
+    "description": "**Broad Phase Collision Detection** is the first step in the collision detection process. Its primary function is to identify which pairs of objects might potentially collide. Rather than examining the entire body of every object for possible collision, it wraps up each one in a simpler shape like a bounding box or sphere, aiming to reduce the number of calculations. The output of this phase is a list of 'candidate pairs' which are passed onto the next phase, often referred to as the narrow phase, for in-depth overlap checks.",
+    "links": []
+  },
+  "YLusnwCba7BIdKOYUoY6F": {
+    "title": "Convexity",
+    "description": "Convexity is a significant concept used in game development, particularly in the narrow phase of collision detection. A shape is considered convex if, for every pair of points inside the shape, the complete line segment between them is also inside the shape. Essentially, a convex shape has no angles pointing inwards. Convex shapes can be of great benefit in game development because they're simpler to handle computationally. For instance, in collision detection algorithms such as separating axis theorem (SAT) and Gilbert–Johnson–Keerthi (GJK), the input shapes are often convex. Non-convex shapes or concave shapes usually require more complex methods for collision detection, often involving partitioning the shape into smaller convex parts.",
+    "links": []
+  },
+  "pG_V12qhS4HevoP_KHTvh": {
+    "title": "Convex",
+    "description": "The term \"convex\" in game development relates primarily to shapes and collision detection within the gaming environment. A shape is convex if all line segments between any two points in the shape lie entirely within the shape. This is an essential concept when programming collision detection and physics engines in games since the mathematical calculations can be more straightforward and efficient when the objects are convex. In addition to this, many rendering algorithms also operate optimally on convex objects, thereby helping improve the game’s graphical performance.",
+    "links": []
+  },
+  "jslk7Gy58VspO1uXGDgBp": {
+    "title": "Concave",
+    "description": "In game development, a shape is said to be \"concave\" if it has an interior angle greater than 180 degrees. In simpler terms, if the shape has a portion \"inwards curved\" or a \"cave-like\" indentation, it's concave. Unlike convex shapes, a straight line drawn within a concave shape may not entirely lie within the boundaries of the shape. Concave shapes add complexity in game physics, especially in collision detection, as there are more points and angles to consider compared to convex shapes. These shapes are commonly seen in game elements like terrains, mazes, game level boundaries and gaming characters. Let's remember that the practical application of concave shapes largely depends on the gameplay requirements and the level of realism needed in the game.",
+    "links": []
+  },
+  "jixffcPBELkhoG0e7Te8g": {
+    "title": "Convex Hull",
+    "description": "The **Convex Hull** is a foundational concept used in various areas of game development, particularly in the creation of physics engines and collision detection. Essentially, it is the smallest convex polygon that can enclose a set of points in a two-dimensional space, or the smallest convex polyhedron for a set of points in a three-dimensional space. It can be thought of as the shape that a rubber band would take if it was stretched around the points and then released. In computational geometry, various algorithms like Graham's Scan and QuickHull have been developed to compute Convex Hulls rapidly. Using Convex Hulls in game engines can drastically improve the performance of collision detection routines as fewer points need to be checked for overlap, which in turn helps in creating smoother gameplay.",
+    "links": []
+  },
+  "bgP9NpD0DJGqN4VCt65xP": {
+    "title": "Convex Decomposition",
+    "description": "`Convex Decomposition` represents a process within game development that involves breaking down complex, concave shapes into simpler, convex shapes. This technique considerably simplifies the computation involved in collision detection, a critical aspect of any game development project that involves physical simulations. In concrete terms, a concave shape has one or more parts that 'cave in' or have recesses, while a convex shape has no such depressions - in simplistic terms, it 'bulges out' with no interior angles exceeding 180 degrees. So, Convex decomposition is essentially a process of breaking down a shape with 'caves' or 'recesses' into simpler shapes that only 'bulge out'.",
+    "links": []
+  },
+  "vmRYaXNVCe0N73xG8bsEK": {
+    "title": "Intersection",
+    "description": "`Intersection` is a concept in the narrow phase of game development where the exact point or points of collision are determined between two potentially colliding objects. This process takes place once a potential collision is determined in the broad phase. Algorithms such as Axis-Aligned Bounding Boxes (AABB), Separating Axis Theorem (SAT), Spherical or Capsule bounding, and many others are used for different intersection tests based on the shape of the objects. The intersection provides valuable data such as the point of contact, direction and depth of penetration, which are used to calculate the accurate physical response in the collision.",
+    "links": []
+  },
+  "kSMz7mZ243qMKtT_YD3AD": {
+    "title": "SAT",
+    "description": "`Sat`, or separating axis theorem, is frequently used in collision detection in game development. Its primary benefit is for simple and fast detection of whether two convex polygons intersect. The theorem is somewhat complex—it works by projecting all points of both polygons onto numerous axes around the shapes, then checking for overlaps. However, it can be relatively time-consuming when dealing with more complex models or numerous objects as it has to calculate the projections, so often it is used in a broad-phase detection system. A deep explanation of how `sat` works might involve some mathematical concepts or visual aids, but this is the foundation of its use in game development.",
+    "links": []
+  },
+  "lwd3Gz9bJEKCIwhXD6m-v": {
+    "title": "GJK",
+    "description": "The **GJK algorithm** (Gilbert–Johnson–Keerthi) is a computational geometry algorithm that is widely used to detect collisions between convex objects in video games and simulations. The primary role of this algorithm is to assess the intersection between two convex shapes. What makes it unique and widely used is its efficiency and accuracy even when dealing with complex three-dimensional shapes. It uses the concept of \"Minkowski Difference\" to simplify its calculations and determine if two shapes are intersecting.\n\nThe algorithm works iteratively, beginning with a single point (the origin) and progressing by adding vertices from the Minkowski Difference, each time refining a simple 'guess' about the direction of the nearest point to the origin until it either concludes that the shapes intersect (the origin is inside the Minkowski difference), or until it can't progress further, in which case the shapes are confirmed not to intersect. This makes it an incredibly powerful and useful tool for game developers.",
+    "links": []
+  },
+  "vWLKYK2KUzV1fO-vQunzW": {
+    "title": "EPA",
+    "description": "The **EPA**, also known as the _Environmental Protection Agency_, is not typically related to game development or the concept of intersection within this context. However, in game development, EPA might refer to an 'Event-driven Process chain Architecture' or some other game-specific acronym. In this domain, different terminologies and acronyms are often used to express complex architectures, designs, or functionalities. If you have encountered EPA in a game development context, it might be best to refer to the specific documentation or guide where it was described for a better understanding. Understanding the context is key to untangle the meaning of such abbreviations.",
+    "links": []
+  },
+  "PLR_4yoRifoTzkOR4c7ym": {
+    "title": "Bounding Volume",
+    "description": "`Bounding Volume` is a simple shape that fully encompasses a more complex game model. It is less expensive to check for the intersection of bounding volumes when compared to checking for intersection of the actual models. Some commonly used types of bounding volume in game development include Axis-Aligned Bounding Boxes (AABBs), Bounding Spheres, and Oriented Bounding Boxes (OBBs). AABBs and Bounding Spheres are simple to implement and work well with static objects, while OBBs are slightly more complex and are often used with dynamic objects that need to rotate.",
+    "links": []
+  },
+  "aTeYGd4JlPr5txNPyBezn": {
+    "title": "AABB",
+    "description": "`AABB`, short for Axis-Aligned Bounding Box, is a commonly used form of bounding volume in game development. It is a box that directly aligns with the axes of the coordinate system and encapsulates a game object. The sides of an AABB are aligned with the axes, which is helpful when carrying out certain calculations, as non-axis-aligned boxes would require more complex math. AABBs are primarily used for broad-phase collision detection, which means checking whether two objects might be in the process of colliding. Although AABBs are relatively conservative and can have more bounding volume than oriented bounding boxes (OBBs), they are simpler and faster to use in collision detection.",
+    "links": []
+  },
+  "7nGtvbxoEAheiF4IPMfPf": {
+    "title": "OBB",
+    "description": "`Oriented Bounding Box (OBB)` is a type of bounding volume used in computer graphics and computational geometry. It is often used to simplify complex geometric objects by correlating them as a box much closer in size and orientation to the actual object. Unlike the `Axis-Aligned Bounding Box (AABB)`, the `OBB` is not constrained to align with the axis, so the box can be rotated. This orientation is usually chosen based on the object's local coordinate system, so the `OBB` maintains its rotation. Properties of an `OBB` include its center, dimensions, and orientation. However, it is worth noting that `OBBs` can be more computationally intensive than `AABBs` due to mathematical complexity.",
+    "links": []
+  },
+  "9Fk3XSINBr2NNdbMtwsIK": {
+    "title": "Spatial Partitioning",
+    "description": "\"Spatial partitioning\" is a technique used in computational geometry, intended to make calculations involving objects in space more efficient. It involves dividing a large virtual space into a series of smaller spaces, or \"partitions\". These partitions can be used to quickly eliminate areas that are irrelevant to a particular calculation or query, thus lowering the overall computational cost. This technique is widely used in game development in contexts such as collision detection, rendering, pathfinding, and more. Various methods exist for spatial partitioning, including grid-based, tree-based (like Quadtree and Octree), and space-filling curve (like Z-order or Hilbert curve) approaches.",
+    "links": []
+  },
+  "STdvFYM9V0a36IkPXjvrB": {
+    "title": "Sort & Sweep",
+    "description": "**Sort and Sweep** is an algorithm used in collision detection in game development which optimizes the process of identifying potential intersecting objects. Here's how it works: first, all objects in the game are sorted along a specific axis (typically the 'x' axis). Then a line (known as the 'sweep line') is moved along this axis. As the line sweeps over the scene, any objects that cross this line are added to an 'active' list. When an object no longer intersects with the sweep line, it's removed from this list. The only objects checked for intersection are those within this 'active' list reducing the number of checks required. This makes sort and sweep an efficient spatial partitioning strategy.",
+    "links": []
+  },
+  "FCc5xwb_G3VsDRXOcg3hV": {
+    "title": "BVH",
+    "description": "BVH, or Bounding Volume Hierarchy, is an algorithm used in 3D computer graphics to speed up the rendering process. It organizes the geometry in a hierarchical structure where each node in the tree represents a bounding volume (a volume enclosing or containing one or more geometric objects). The root node of the BVH contains all other nodes or geometric objects, its child nodes represent a partition of the space, and the leaf nodes are often individual geometric objects. The main objective of using BVH is to quickly exclude large portions of the scene from the rendering process, to reduce the computational load of evaluating every single object in the scene individually.",
+    "links": []
+  },
+  "XHFV4d6Ab4kWQ3-XcZTyT": {
+    "title": "DBVT",
+    "description": "`DBVT` or `Dynamic Bounding Volume Tree` is an acceleration data structure that's primarily used in physics simulations like collision detection. It's a type of BVH (`Bounding Volume Hierarchy`), but the unique aspect of a DBVT is its handling of dynamic objects. As the name suggests, it's specifically designed to efficiently handle changing scenarios, such as objects moving or environments evolving, better than a typical BVH. Unlike a static BVH, a DBVT dynamically updates the tree as objects move, maintaining efficiency of collision queries. It primarily does this through tree rotations and refitting bounding volumes rather than fully rebuilding the tree. This makes DBVT a highly appealing option for scenarios with considerable dynamics.",
+    "links": []
+  },
+  "1yK8TH4Pn7Ag8VQoug54i": {
+    "title": "CCD",
+    "description": "**CCD (Continuous Collision Detection)** is a sophisticated technique used in detecting collisions within games, more advanced than the traditional discrete collision. Rather than checking for collisions at designated time frames, CCD checks for any possible collisions that may happen during the entire time period or motion path of the moving object. This can prevent instances of \"tunneling\", where an object moves so fast that it passes through walls or obstacles undetected by discrete collision detection due to being at different points in one frame to another. Although more computationally heavy than discrete detection, CCD offers an increased accuracy in collision detection, making it vital in games where precise movements are needed.",
+    "links": []
+  },
+  "fv5tivGad2P9GRZOodfn2": {
+    "title": "Game Engine",
+    "description": "A _Game Engine_ is a software framework designed to facilitate the creation and development of video games. Developers use them to create games for consoles, mobile devices, and personal computers. The core functionality typically provided by a game engine includes a rendering engine (\"renderer\") for 2D or 3D graphics, a physics engine or collision detection (and collision response), sound, scripting, animation, artificial intelligence, networking, streaming, memory management, and a scene graph. Game Engines can save a significant amount of development time by providing these reusable components. However, they aren't one-size-fits-all solutions, as developers must still customize much of the code to fit their games' unique needs. Some popular game engines are Unity, Unreal Engine, and Godot.",
+    "links": []
+  },
+  "7OffO2mBmfBKqPBTZ9ngI": {
+    "title": "Godot",
+    "description": "Godot is an open-source, multi-platform game engine that is known for being feature-rich and user-friendly. It is developed by hundreds of contributors from around the world and supports the creation of both 2D and 3D games. Godot uses its own scripting language, GDScript, which is similar to Python, but it also supports C# and visual scripting. It is equipped with a unique scene system and comes with a multitude of tools that can expedite the development process. Godot's design philosophy centers around flexibility, extensibility, and ease of use, providing a handy tool for both beginners and pros in game development.",
+    "links": [
+      {
+        "title": "Godot in 100 Seconds",
+        "url": "https://m.youtube.com/watch?v=QKgTZWbwD1U",
+        "type": "video"
+      }
+    ]
+  },
+  "a6H-cZtp3A_fB8jnfMxBR": {
+    "title": "Unreal Engine",
+    "description": "The **Unreal Engine** is a powerful game development engine created by Epic Games. Used by game developers worldwide, it supports the creation of high-quality games across multiple platforms such as iOS, Android, Windows, Mac, Xbox, and PlayStation. Unreal Engine is renowned for its photo-realistic rendering, dynamic physics and effects, robust multiplayer framework, and its flexible scripting system called Blueprint. The engine is also fully equipped with dedicated tools and functionalities for animation, AI, lighting, cinematography, and post-processing effects. The most recent version, Unreal Engine 5, introduces real-time Global Illumination and makes film-quality real-time graphics achievable.",
+    "links": [
+      {
+        "title": "Unreal Engine Documentation",
+        "url": "https://dev.epicgames.com/documentation/en-us/unreal-engine/unreal-engine-5-4-documentation",
+        "type": "article"
+      },
+      {
+        "title": "Unreal Engine YouTube Channel",
+        "url": "https://m.youtube.com/channel/UCBobmJyzsJ6Ll7UbfhI4iwQ",
+        "type": "article"
+      },
+      {
+        "title": "Unreal Source Discord",
+        "url": "https://discord.gg/unrealsource",
+        "type": "article"
+      },
+      {
+        "title": "Unreal in 100 Seconds",
+        "url": "https://www.youtube.com/watch?v=DXDe-2BC4cE",
+        "type": "video"
+      }
+    ]
+  },
+  "CeAUEN233L4IoFSZtIvvl": {
+    "title": "Native",
+    "description": "You don't necessarily have to use tools like Unreal, Unity3d, or Godot to make games. You can also use native languages like C++ or Rust to make games. However, you will have to do a lot of work yourself, and you will have to learn a lot of things that are already done for you in game engines.",
+    "links": []
+  },
+  "rNeOti8DDyWTMP9FB9kJ_": {
+    "title": "Unity 3D",
+    "description": "**Unity 3D** is a versatile, cross-platform game engine that supports the development of both 2D and 3D games. This game engine allows users to create a wide variety of games including AR, VR, Mobile, Consoles, and Computers in C#. It provides a host of powerful features and tools, such as scripting, asset bundling, scene building, and simulation, to assist developers in creating interactive content. Unity 3D also boasts a large, active community that regularly contributes tutorials, scripts, assets, and more, making it a robust platform for all levels of game developers.",
+    "links": [
+      {
+        "title": "Unity in 100 Seconds",
+        "url": "https://www.youtube.com/watch?v=iqlH4okiQqg",
+        "type": "video"
+      }
+    ]
+  },
+  "4YgbrXLXf5mfaL2tlYkzk": {
+    "title": "Programming Languages",
+    "description": "Programming languages are very crucial to game development as they are the backbone of game design and functionality. A variety of languages can be used, but some are more commonly preferred in the industry due to their robustness and efficiency. The most popular ones include C++, C#, and Java. **C++**, a high-level language primarily used for developing video games, is known for its speed and efficiency. **C#**, which was developed by Microsoft, is extensively used with the Unity game engine to develop multi-platform games. **Java** is well-established in the sector as well, and it often utilized in the development of Android games. It's pivotal for a game developer to select a language that aligns with the project's requirements and nature. Despite the programming language you choose, a deep understanding of its constructs, logic, and capabilities is required for successful game development.",
+    "links": []
+  },
+  "jsq0UXnIIC0Z_nbK2w48f": {
+    "title": "C/C++",
+    "description": "**C** and **C++ (commonly known as CPP)** are two of the most foundational high-level programming languages in computer science. **C** was developed in the 1970s and it is a procedural language, meaning it follows a step-by-step approach. Its fundamental principles include structured programming and lexical variable scope.\n\nOn the other hand, **C++** follows the paradigm of both procedural and object-oriented programming. It was developed as an extension to C to add the concept of \"classes\" - a core feature of object-oriented programming. C++ enhances C by introducing new features like function overloading, exception handling, and templates.\n\nBoth of these languages heavily influence modern game development, where they often serve as the backend for major game engines like Unreal. Game developers use these languages for tasks related to rendering graphics, compiling game logic, and optimizing performance.",
+    "links": []
+  },
+  "Ph3ZqmSnwwzUBUC-6dgf-": {
+    "title": "C#",
+    "description": "**CSharp (C#)** is a modern, object-oriented programming language developed and maintained by Microsoft. It's primarily used for developing desktop applications and, more prominently, for Windows applications within the [Microsoft.Net](http://Microsoft.Net) framework. However, the language is versatile and has a wide range of uses in web services, websites, enterprise software, and even mobile app development. C# is known for its simplicity, type-safety, and support for component-oriented software development. It's also been adopted by Unity, a widely used game engine, thus making it one of the preferred languages for game development.",
+    "links": []
+  },
+  "AaRZiItRcn8fYb5R62vfT": {
+    "title": "GDScript",
+    "description": "GDScript is a high-level, dynamically-typed programming language designed specifically for the Godot Engine, an open-source game development platform. It is tailored for ease of use and rapid development of game logic and functionality. GDScript features a syntax similar to Python, which simplifies learning and coding for developers familiar with Python, while providing direct access to Godot's rich set of built-in functions and game-specific APIs. The language integrates closely with Godot's scene system and scripting environment, enabling developers to create and manipulate game objects, handle input, and control game behavior efficiently.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "GDScript Website",
+        "url": "https://gdscript.com/",
+        "type": "article"
+      },
+      {
+        "title": "How to program in Godot - GDScript Tutorial",
+        "url": "https://www.youtube.com/watch?v=e1zJS31tr88",
+        "type": "video"
+      }
+    ]
+  },
+  "ts9pWxUimvFqfNJYCmNNw": {
+    "title": "Rust",
+    "description": "**Rust** is a modern, open-source, multi-paradigm programming language designed for performance and safety, especially safe concurrency. It was initially designed by Mozilla Research as a language that can provide memory safety without garbage collection. Since then, it has gained popularity due to its features and performance that often compare favorably to languages like C++. Its rich type system and ownership model guarantee memory-safety and thread-safety while maintaining a high level of abstraction. Rust supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles.\n\n[Learn Rust full tutorial](https://youtu.be/BpPEoZW5IiY?si=lyBbBPLXQ0HWdJNr)",
+    "links": []
+  },
+  "AJp_QRLgSG5ETXDIjUjmm": {
+    "title": "Python",
+    "description": "Python is a popular high-level programming language that was designed by Guido van Rossum and published in 1991. It is preferred for its simplicity in learning and usage, making it a great choice for beginners. Python's design philosophy emphasizes code readability with its use of significant indentation. Its language constructs and object-oriented approach aim to help developers write clear, logical code for small and large-scale projects. Python is dynamically-typed and garbage-collected. Moreover, it supports multiple programming paradigms, including procedural, object-oriented, and functional programming. Python is often used for web development, software development, database operations, and machine learning. Although not typically used for game development, some game developers utilize Python for scripting and automating tasks.",
+    "links": []
+  },
+  "lIb5MeDoqVj6HycveOgTS": {
+    "title": "Computer Graphics",
+    "description": "Computer Graphics is a subfield of computer science that studies methods for digitally synthesizing and manipulating visual content. It involves creating and manipulating visual content using specialized computer software and hardware. This field is primarily used in the creation of digital and video games, CGI in films, and also in visual effects for commercials. The field is divided into two major categories: **Raster graphics** and **Vector graphics**. Raster graphics, also known as bitmap, involve the representation of images through a dot matrix data structure, while Vector graphics involve the use of polygons to represent images in computer graphics. Both of these methods have their unique usage scenarios. Other concepts integral to the study of computer graphics include rendering (including both real-time rendering and offline rendering), animation, and 3D modeling. Generally, computer graphics skills are essential for game developers and animation experts.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "How do Video Game Graphics Work?",
+        "url": "https://www.youtube.com/watch?v=C8YtdC8mxTU",
+        "type": "video"
+      }
+    ]
+  },
+  "JW5c_0JEtO-OiBoXUia6A": {
+    "title": "Ray Tracing",
+    "description": "Ray tracing is a rendering technique in computer graphics that simulates the physical behavior of light. It generates images with a high degree of visual realism, as it captures shadows, reflections, and refracts light. Ray tracing follows the path of light backwards from the camera (eye) to the source (light object), calculating the color of each pixel in the image on the way. The color value calculation considers the object from which the ray has reflected or refracted, and the nature of the light source i.e. whether it's ambient, point or spot. Ray tracing algorithm handles effects that rasterization algorithms like scanline rendering and 'Z-buffer' find complex to handle.",
+    "links": []
+  },
+  "vYNj9nzu90e9xlrzHULnP": {
+    "title": "Rasterization",
+    "description": "In the realm of computer graphics, **Rasterization** refers to the process of converting the image data into a bitmap form, i.e., pixels or dots. It is predominantly used in 3D rendering where three-dimensional polygonal shapes are transformed into a two-dimensional image, possessing height, width, and color data. It is a scan-conversion process where vertices and primitives, upon being processed through the graphics pipeline, are mathematically converted into fragments. Every fragment finds its position in a raster grid. The process culminates in fragments becoming pixels in the frame buffer, the final rendered image you see on the screen. However, it's essential to note that rasterization does limit the image's resolution to the resolution of the device on which it is displayed.",
+    "links": []
+  },
+  "shSRnMf4NONuZ3TGPAoQc": {
+    "title": "Graphics Pipeline",
+    "description": "The **Graphics Pipeline**, also often referred to as the rendering pipeline, is a sequence of steps that a graphics system follows to convert a 3D model into a 2D image or view that can be displayed onto a screen. These steps typically include transformation, clipping, lighting, rasterization, shading, and other processes. Each step in the pipeline represents an operation that prepares or manipulates data to be used in downstream stages. The pipeline begins with a high-level description of a scene and ends with the final image rendered onto the screen. It is a primary concept in computer graphics that developers should learn as it can help in efficient rendering and high-quality visualization.",
+    "links": []
+  },
+  "rmtxybcavWV6A53R4ZWgc": {
+    "title": "Sampling",
+    "description": "**Sampling** in computer graphics is a method used to convert a continuous mathematical function (image, signal, light and sound), into a discrete digital representation. The process is done by taking snapshots at regular intervals which are also known as samples, and it's this that gives us the concept of 'sampling'. Some common types of sampling techniques include: uniform sampling (evenly spaced samples), random sampling (samples taken at random intervals), and jittered sampling (a compromise between uniform and random sampling). The higher the sampling rate, the more accurately the original function can be reconstructed from the discrete samples. Effective sampling is a significant aspect of achieving realistic computer graphics.",
+    "links": []
+  },
+  "qIrePusMuvcUva9LMDmDx": {
+    "title": "Shader",
+    "description": "Shaders are a type of software used in 3D computer graphics. They are utilized to render quality visual effects by making calculations and transformations on image data. Also, a shader is responsible for determining the final color of an object. There are several types of shaders: vertex shaders, geometry shaders, pixel shaders, and compute shaders. Each of these is programmed to manipulate specific attributes of an image, such as its vertices, pixels, and overall geometry. They are essential tools for game developers aiming to produce realistic and engaging visual experiences.",
+    "links": []
+  },
+  "WVgozaQPFbYthZLWMbNUg": {
+    "title": "Rendering Equation",
+    "description": "The **Render Equation**, also known as the **Rendering Equation**, is a fundamental principle in computer graphics that serves as the basis for most advanced lighting algorithms today. First introduced by James Kajiya in 1986, it defines how light interacts with physical objects in a given environment. The equation tries to simulate light's behavior, taking into account aspects such as transmission, absorption, scattering, and emission. The equation can be computationally intensive to solve accurately. It's worth mentioning, however, that many methods have been developed to approximate and solve it, allowing the production of highly realistic images in computer graphics.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Interactive Graphics 12 - The Rendering Equation",
+        "url": "https://www.youtube.com/watch?v=wawf7Am6xy0",
+        "type": "video"
+      }
+    ]
+  },
+  "eI2jym4AAz3ani-lreSKE": {
+    "title": "Reflection",
+    "description": "Reflection in game development, specifically in shaders, is a phenomena that simulates the bouncing off of light from objects similar to the way it happens in the real world. Shaders replicate this effect by emitting rays from the lighting source against the object's surface. When the ray strikes the surface, it will calculate the light’s color and angle to define how light should reflect off that surface. Reflection in shaders can further be classified into two types: Specular Reflection and Diffuse Reflection. Specular Reflection is the mirror-like reflection of light from a surface, where each incident ray is reflected with the light ray reflected at an equal but opposite angle. Diffuse Reflection, on the other hand, is the reflection of light into many directions, giving a softer effect. These reflections are quantified in computer graphics often using a reflection model such as the Phong reflection model or the Lambertian reflectance model.",
+    "links": []
+  },
+  "0g1z5G2dsF4PTIfFAG984": {
+    "title": "Diffuse",
+    "description": "",
+    "links": []
+  },
+  "odfZWKtPbb-lC35oeTCNV": {
+    "title": "Specular",
+    "description": "`Specular` reflections are mirror-like reflections. In these cases, the rays of light are reflected, more than they are absorbed. The angle of incidence is equal to the angle of reflection, that is to say that the angle at which the light enters the medium and then bounces off, the angle of the beam that bounced off would be the same.\n\nLearn more from the following resources:\n\n\\-[@video@Specular reflection](https://www.youtube.com/watch?v=2cFvJkc4pQk)",
+    "links": []
+  },
+  "THMmnx8p_P0X-dSPoHvst": {
+    "title": "Mapping",
+    "description": "\"Mapping\" in game development, especially in the context of shaders, predominantly refers to Texture Mapping and Normal Mapping.\n\n*   **Texture Mapping**: This is the application of a texture (an image or colour data) onto a 3D model's surface. It's a process of defining how a 2D surface wraps around a 3D model or the way that a flat image is stretched across a model's surface to paint its appearance. This could be anything from the colour of objects to their roughness or reflectivity.\n    \n*   **Normal Mapping**: This is a technique used to create the illusion of complexity in the surface of a 3D model without adding any additional geometry. A Normal Map is a special kind of texture that allows the addition of surface details, such as bumps, grooves, and scratches which catch the light as if they are represented by real geometry, making a low-polygon model appear as a much more complex shape.",
+    "links": []
+  },
+  "iBZ1JsEWI0xuLgUvfWfl-": {
+    "title": "Texture",
+    "description": "`Texture` is the visual quality of an object. Where the `mesh` determines the shape or `topology` of an object, the texture describes the quality of said object. For instance, if there is a spherical mesh, is it supposed to be shiny? is it supposed to be rough? is it supposed to be of rock or of wood? questions of this ilk are often resolved using textures. Textures are often just 2D images that are wrapped onto 3D meshes. The 3D mesh is first divided into segments and unfurled; the 3D meshes are converted into 2D chunks, this process is known as `UV Unwrapping`. Once a mesh has been unwrapped, the textures in the form of an image are applied to the 2D chunks of the 3D mesh, this way the texture knows how to properly wrap around the mesh and avoid any conflicts. Textures determine the visual feel and aesthetics of the game.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "How Nintendo textures work",
+        "url": "https://www.youtube.com/watch?v=WrCMzHngLxI",
+        "type": "video"
+      },
+      {
+        "title": "How Pixar textures work",
+        "url": "https://www.youtube.com/watch?v=o_I6jxlN-Ck",
+        "type": "video"
+      }
+    ]
+  },
+  "r4UkMd5QURbvJ3Jlr_H9H": {
+    "title": "Bump",
+    "description": "`Bump` is very similar to texture. It is, as a matter of fact, a type of texture itself. If you take the texture of a bricked wall, it will becoming increasingly obvious that the amount of detail present inside the wall, if geometrically processed would be incredibly demanding and wasteful. In order to combat this ineffeciency, the `bump` maps were created. Traditionally, a flat texture would just be an image of something called a `color map`, that is to say, where does each individual color of the pixel should be to represent a texture. When you take the picture of your floor, wall, or any object, that image in essence is the color map. The bump map is different as it informs the texture about it's `normal` values. So, if you take a flat 2D mesh and apply a bump map on it, it will render the same 2D mesh with all the normal values baked into the flat 2D mesh, creating a graphically effect mimicking 3-dimensionality.\n\nThere is also something known as a normal map, and displacement maps.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Normals, Normal maps and Bump maps",
+        "url": "https://www.youtube.com/watch?v=l5PYyzsZED8",
+        "type": "video"
+      },
+      {
+        "title": "Bump, normal and displacement",
+        "url": "https://www.youtube.com/watch?v=43Ilra6fNGc",
+        "type": "video"
+      }
+    ]
+  },
+  "YGeGleEN203nokiZIYJN8": {
+    "title": "Parallax",
+    "description": "",
+    "links": []
+  },
+  "9cBOfj58I4hBlxlQIyV9g": {
+    "title": "Horizon",
+    "description": "",
+    "links": []
+  },
+  "1RdyzTI_TXqmct2bIbNh9": {
+    "title": "Computer Animation",
+    "description": "Computer Animation\n------------------\n\nComputer animation refers to the art of creating moving images via the use of computers. Increasingly, it's becoming a critical component in the game development industry. Essentially, it's divided into two categories, 2D animation and 3D animation. 2D animation, also referred to as vector animation, involves creation of images in a two-dimensional environment, including morphing, twining, and onion skinning. On the other hand, 3D animation, also known as CGI, involves moving objects and characters in a three-dimensional space. The animation process typically involves the creation of a mathematical representation of a three-dimensional object. This object is then manipulated within a virtual space by an animator to create the final animation. Software like Unity, Maya, and Blender are commonly used for computer animation in game development.",
+    "links": []
+  },
+  "WK6fLWJq9Vh2ySVrSqd-U": {
+    "title": "Color",
+    "description": "In the realm of computer graphics, color plays an integral role. It can be defined in various color models such as RGB (Red, Green, Blue), CYMK (Cyan, Yellow, Magenta, Black), and others. RGB is a color model that combines the primary colors (red, green, blue) in different amounts to produce a spectrum of colors. This model is often used in digital displays. In contrast, CMYK is a color model used in color printing. It uses cyan, magyenta, yellow, and black as the primary colors. HSL (Hue, Saturation, Lightness) and HSV (Hue, Saturation, Value) are other useful models that represent colors based on human perceptions. Another important element of color in computer graphics is the color depth, also known as bit depth, which determines the number of colors that can be displayed at once.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Pixar in a Box - Color",
+        "url": "https://www.khanacademy.org/computing/pixar/animate/ball/v/intro-animation",
+        "type": "video"
+      }
+    ]
+  },
+  "1S1qPogijW2SQCiF7KLZe": {
+    "title": "Visual Perception",
+    "description": "Visual Perception is a fundamental aspect of game development, widely explored within the field of computer graphics. It involves the ability to interpret and understand the visual information that our eyes receive, essential to create immersive and dynamic visual experiences in games. The study involves the understanding of light, color, shape, form, depth, and motion, among others, which are key elements to create aesthetically pleasing and engaging graphics. Making full use of visual perception allows the game developers to control and manipulate how the gamers interact with and experience the game world, significantly enhancing not only the visual appeal but also the overall gameplay.",
+    "links": []
+  },
+  "RgC9TOc0wbr2QSuvrpIDV": {
+    "title": "Tone Reproduction",
+    "description": "`Tone Reproduction` or `Tone Mapping` is the technique used in computer graphics to simulate the appearance of high-dynamic-range images in media with a more limited dynamic range. Print-outs, CRT, LCD monitors, and other displays can only reproduce a reduced dynamic range. This technique is widely used in gaming development, where developers employ it to improve the visual experience. The process involves taking light from a scene and mapping it to a smaller range of tones while preserving the visual appearance—i.e., regarding brightness, saturation, and hue. There are various tone mapping algorithms available, each with unique attributes suitable for different imaging tasks.",
+    "links": []
+  },
+  "DDN3mn0LTueBhjRzXFcbU": {
+    "title": "Lighting and Shadow",
+    "description": "**Lighting and Shadows** are paramount elements in computer graphics, significantly contributing to the visual realism of a game. They create depth and a sense of a three-dimensional space in a two-dimensional display. **Lighting** in game development mimics real-world light properties. It involves calculating how light interacts with different objects and surfaces based on their material characteristics and the light's intensity, direction, and color. Various algorithms, like Ray Tracing or Rasterization, are used to simulate these interactions. On the other hand, **shadows** are the areas unlit due to the blockage of light by an object. Producing realistic shadows involves complex computations, factoring in the light's position, the blocking object's shape and size, and the affected area's distance. Shadow Mapping and Shadow Volume are common techniques for creating shadows in game development. Special attention to these aspects can dramatically increase the perceived realism and immersion in the game environment.",
+    "links": []
+  },
+  "ygtru6fqQ3gpFZRN_I8rP": {
+    "title": "Shadow Map",
+    "description": "Shadow mapping is a technique used in computer graphics to add shadows to a scene. This process involves two steps - generating the shadow map and then rendering the scene.\n\nIn the shadow map generating step, the scene is rendered from the perspective of the light source capturing depth information. This results in a texture that stores the distance from the light to the nearest surface along each light direction, a “shadow map”.\n\nIn the scene rendering step, the scene is rendered from the camera’s perspective. For each visible surface point, its distance from the light is calculated and compared to the corresponding stored distance in the shadow map. If the point's distance is greater than the stored distance, the point is in shadow; otherwise, it's lit. This information is used to adjust the color of the point, producing the shadow effect.",
+    "links": []
+  },
+  "Wq8siopWTD7sylNi0575X": {
+    "title": "2D",
+    "description": "",
+    "links": []
+  },
+  "cv1-AwewuqJsZDBI3h84G": {
+    "title": "Cube",
+    "description": "",
+    "links": []
+  },
+  "Lu38SfZ38y89BffLRMmGk": {
+    "title": "Cascaded",
+    "description": "",
+    "links": []
+  },
+  "VLrcBE1vb6N5fw5YESCge": {
+    "title": "Light Source",
+    "description": "In game development, a **light source** is a critical component that impacts the visual appeal and realism of the scene. It represents any object in the game scene that emits light, such as the sun, a lamp, or a torch. Light sources can be categorized as static or dynamic. Static light sources do not move or change throughout the game, while dynamic light sources can move and their properties can change in real-time. The properties of light sources that can be manipulated include intensity (how bright the light is), color, range (how far the light extends), direction, and type (point, directional, or spot). The lighting and shading effects are then computed based on these light source properties and how they interact with various objects in the game scene.",
+    "links": []
+  },
+  "foD8K7V0yIxgeXwl687Bv": {
+    "title": "Directional",
+    "description": "",
+    "links": []
+  },
+  "aNhyXWW2b7yKTv8y14zk9": {
+    "title": "Point",
+    "description": "Point lights are one of the most common types of lights used in computer graphics and games. They resemble real-world light bulbs, emitting light uniformly in all directions.\n\nThese lights are available out of the box in most game engines and offer a range of customizable parameters, such as intensity, falloff, color, and more.\n\nPoint lights are the most straightforward type of light, making them ideal for quickly and intuitively lighting up your scenes.",
+    "links": []
+  },
+  "FetbhcK1RDt4izZ6NEUEP": {
+    "title": "Spot",
+    "description": "Spotlights are a common type of light in computer graphics and games that mimic the behavior of real-world spotlights. They offer a range of parameters to adjust their behavior, such as radius, cone angle, falloff, and intensity.\n\nSpotlights are readily available out of the box in both Unreal and Unity game engines, making them an accessible and powerful tool for adding realistic and dynamic lighting to your scenes.",
+    "links": []
+  },
+  "sC3omOmL2DOyTSvET5cDa": {
+    "title": "Infinite",
+    "description": "",
+    "links": []
+  },
+  "OcxesFnB5wO6VXrHYnhz-": {
+    "title": "Visibility and Occlusion",
+    "description": "\"Visibility and occlusion\" in computer graphics refers to the process of determining which parts of a particular object are visible from a certain viewpoint and which are hidden. \"Occlusion\" describes the phenomenon where an object is blocked from view by another object. Understanding these concepts is important for creating realistic renderings in game design. Real-time engines typically use data structures like BSP-trees, Quad-trees or Octrees to quickly identify occlusion. Advanced techniques such as Occlusion culling and Z-buffering are used to further optimize the representation of visible and hidden parts of 3D objects. Understanding the depths and dimensions related to visibility and occlusion empowers the game developer to enhance presentation and performance.",
+    "links": []
+  },
+  "MlLYqO_8JDNOwKRvaM-bf": {
+    "title": "Occluder",
+    "description": "An **Occluder** in game development is basically a tool or method used to hide other objects in the game environment. When a certain object, which is known as the occluder, blocks the line of sight to another object from the camera's perspective, the hidden or blocked object does not need to be rendered. This object could be anything from a building to a terrain feature. The process of managing these occluders is known as occlusion culling. The purpose of using occluders is to optimize the game and improve its performance by reducing unnecessary rendering workload. However, it's important to note that setting up occluders requires careful planning to ensure that it does not impact the gameplay or visual quality.",
+    "links": []
+  },
+  "1gdDeUPBRco10LpOxug4k": {
+    "title": "Culling",
+    "description": "**Culling** is a performance optimization strategy employed in game development to improve efficiency and speed. _Culling_ helps in reducing the rendering workload by eliminating the elements that are not visible to the player or are outside the viewport of the game. There are several types of culling, two main being; **frustum culling** and **occlusion culling**. Frustum culling involves eliminating objects that are outside of the camera's field of view. On the other hand, Occlusion culling discards objects that are hidden or blocked by other objects. Culling ensures that only the elements that are necessary or add value to the player's experience are processed.",
+    "links": []
+  },
+  "xP_VDMu1z9jiVnZaBFKJQ": {
+    "title": "Clipping",
+    "description": "`Clipping` is a fundamental technique in computer graphics primarily used for efficiently rendering a three-dimensional scene. This process involves eliminating certain parts of objects in the scene that are out-of-view or obstructed by other objects. Clipping can occur in various ways, one of the most common methods being `View-frustum culling` where objects completely outside of the camera view are discarded. The aim of clipping is to optimize the graphic rendering pipeline by reducing the number of polygons that the graphic hardware needs to process. Consequently, this helps in improving the speed and overall performance of the rendering process.",
+    "links": []
+  },
+  "2ocwC0P1-ZFmjA9EmA1lV": {
+    "title": "Fog",
+    "description": "",
+    "links": []
+  },
+  "UcLGWYu41Ok2NYdLNIY5C": {
+    "title": "Frustum",
+    "description": "Frustum culling is a standard practice in computer graphics, used in virtually all games to optimize performance by not rendering objects outside of your field of view. Think of your field of view as a frustum, a truncated pyramid shape. The farthest side is called the far clip plane, and the closest side is the near clip plane. Any object in the game that doesn't fall within this frustum is culled, meaning it’s not rendered, to improve performance. This feature comes built-in with Unreal Engine.\n\nYou can also adjust the near and far clip planes to fine-tune culling. For example, if an object is too close to the camera, it may disappear because it crosses the near clip plane threshold. Similarly, objects that are too far away might be culled by the far clip plane. In some cases, distant objects are LOD-ed (Level of Detail), an optimization technique that reduces the detail of the mesh the farther you are from it, and increases detail as you get closer.\n\nFrustum culling is a fundamental technique that is implemented in virtually all modern games to ensure efficient rendering and smooth gameplay.",
+    "links": [
+      {
+        "title": "Frustum Culling - Game Optimization 101 - Unreal Engine",
+        "url": "https://www.youtube.com/watch?v=Ql56s1erTMI",
+        "type": "video"
+      }
+    ]
+  },
+  "_1LkU258hzizSIgXipE0b": {
+    "title": "Light",
+    "description": "",
+    "links": []
+  },
+  "lqfW8hkuN3vWtacrqBBtI": {
+    "title": "Shadow",
+    "description": "",
+    "links": []
+  },
+  "-r15srXTBLnUGokpXKclH": {
+    "title": "Polygon",
+    "description": "",
+    "links": []
+  },
+  "GHfLMtgmc36OCvjQvW_Su": {
+    "title": "Polyhedron",
+    "description": "",
+    "links": []
+  },
+  "AEAVc8Ih4fctSGGVJG0Np": {
+    "title": "Stencil Shadow",
+    "description": "`Stencil shadows` are a technique used in 3D computer graphics for creating shadows. The stencil shadow algorithm operates by treating a shadow as a 3D volume of space, known as a shadow volume. Any part of the scene that lies inside this shadow volume will be in shadow. If it lies outside the shadow volume, it will be in light. The shadow volume is created by extruding the polygonal silhouette of a 3D object into space along the lines of sight from the light source. For equivalent complex objects, the number of edges or vertices to fill the stencil buffer will generally be less than the number of pixels needed to compute shadow maps, making stencil shadows more efficient in that regard. However, the shadows produced by this technique can look blocky or unrealistic if not further refined.",
+    "links": []
+  },
+  "Kx7O7RLp7aPGtOvK8e314": {
+    "title": "Graphics API",
+    "description": "A Graphics API (Application Programming Interface) is a collection of commands, functions, protocols, and tools that game developers use to build games. It forms an interface between the game and the hardware of the device, usually a computer or console, and assists in rendering 2D and 3D graphics performance. Complex tasks such as drawing polygons, texturing, or lighting are encapsulated in a more manageable, higher-level process by the API. Common examples are Vulkan, DirectX, OpenGL, and Metal. Each one varies in availability and performance across different platforms and devices and has unique features that can be utilized for game development.",
+    "links": []
+  },
+  "bgWFV09AtDv1yJS5t0EaB": {
+    "title": "DirectX",
+    "description": "**DirectX** is a collection of Application Programming Interfaces (APIs) developed by Microsoft to handle tasks related to multimedia, especially game programming and video, on Microsoft platforms. It was first introduced in 1995 and has become a crucial component for PC gaming. DirectX serves as an intermediary between a hardware and a software, managing the state of the hardware and giving commands to it. Some technologies under DirectX includes Direct3D for 3D graphics, DirectDraw for 2D graphics, DirectSound for sound, and DirectInput for interfacing with input devices such as keyboard and mouse.",
+    "links": []
+  },
+  "ffa5-YxRhE3zhWg7KXQ4r": {
+    "title": "OpenGL",
+    "description": "Open GL, also known as Open Graphics Library, is a cross-language, cross-platform API designed to render 2D and 3D vector graphics. As a software interface for graphics hardware, Open GL provides programmers the ability to create complex graphics visuals in detail. It was first developed by Silicon Graphics Inc. in 1992 and quickly became a highly popular tool in the graphics rendering industry. Open GL is widely used in CAD, virtual reality, scientific visualization, information visualization, and flight simulation. It is also used in video games production where real-time rendering is a requirement. The API is designed to work with a broad range of hardware from different manufacturers. Being open-source, Open GL's code capabilities can be extended by anyone in the software community.",
+    "links": [
+      {
+        "title": "OpenGL Tutorials",
+        "url": "https://youtube.com/playlist?list=PLPaoO-vpZnumdcb4tZc4x5Q-v7CkrQ6M-&si=Mr71bYJMgoDhN9h-",
+        "type": "video"
+      }
+    ]
+  },
+  "CeydBMwckqKll-2AgOlyd": {
+    "title": "WebGL",
+    "description": "`WebGL` (Web Graphics Library) is a JavaScript API that is used to render interactive 2D and 3D graphics within any compatible web browser without the use of plug-ins. It leverages the power of the Graphics Processing Unit (GPU), which provides high-efficiency rendering. WebGL programs consist of control code written in JavaScript and shader code that's written in OpenGL Shading Language (GLSL), allowing developers to control the fine details of graphics rendering. Besides its compatibility with HTML5 and its ability to render on any platform that supports the web, WebGL is entirely integrated into all web standards, facilitating GPU-accelerated image processing and effects.",
+    "links": []
+  },
+  "wYUDJb-q1rtM4w2QV3Wr1": {
+    "title": "HLSL",
+    "description": "**HLSL** stands for High-Level Shader Language, and it is the proprietary shading language developed by Microsoft for use with the Microsoft Direct3D API. Just like its counterpart from OpenGL - GLSL, it opens up the power of programmable GPUs for developers by providing capability for creating customized rendering effects or performing operations that are computationally expensive in CPU. HLSL resembles the C programming language, thereby making it easier for developers coming from traditional programming backgrounds. It is often considered an integral part of the Direct X ecosystem and is used for developing complex and visually impressive graphics for games.",
+    "links": []
+  },
+  "j8mWMFMQCEIPUzegDDsm1": {
+    "title": "GLSL",
+    "description": "GLSL (Graphics Library Shader Language) is a high-level shading language inspired by C, based on the syntax of the OpenGL Shading Language. It is used in graphics programming for defining how the graphical content should look. GLSL allows developers to harness the power of modern GPUs (Graphics Processing Units), enabling direct, unconstrained control over graphics rendering. A key aspect of the language is its ability to create shaders, which are small programs that run on the GPU. Shaders are used for various graphical effects like vertex manipulation, pixel color calculations, or post-processing effects.",
+    "links": []
+  },
+  "EVOiWAeZsIvjLTt3EYu-6": {
+    "title": "OpenGL ES",
+    "description": "OpenGL ES (Open Graphics Library for Embedded Systems) is a simplified version of OpenGL, designed for use on systems with lower computational power, such as mobile devices and embedded systems. Despite its semantic simplifications, OpenGL ES still retains high versatility and capability, allowing for high-performance 2D and 3D graphics on these smaller, less powerful systems. OpenGL ES has become particularly popular in mobile game development, with major platforms like Android and iOS providing full support for it. The API is divided into several versions, the latest of which, OpenGL ES 3.2, was released in 2016.",
+    "links": []
+  },
+  "oEznLciLxZJaulMlBGgg4": {
+    "title": "Metal",
+    "description": "Metal is a low-level, high-performance, application programming interface (API) developed by Apple. It debuted in iOS 8 and is dedicated to graphics and data-parallel computations. Essentially, it's designed to exploit modern GPU architecture on Apple devices, optimizing performance and power efficiency. This API applies to various platforms, including iOS, macOS, and tvOS. In contrast to high-level APIs like OpenGL, Metal offers a much lower overhead, allowing more direct control over the GPU. For developers, it means that they can squeeze better performance out of the hardware compared to higher-level APIs. With Metal, developers have a much more detailed view and control on the GPU which results in better graphical output and smoother performance.",
+    "links": [
+      {
+        "title": "Metal Documentation",
+        "url": "https://developer.apple.com/metal/",
+        "type": "article"
+      }
+    ]
+  },
+  "yPfhJSTFS7a72UcqF1ROK": {
+    "title": "Vulkan",
+    "description": "Vulkan is a high-performance, cross-platform API for graphics and computation tasks published by the Khronos Group. Unlike other graphics APIs, Vulkan provides developers with direct control over the GPU and aims to take full advantage of multicore processors, enabling significant performance gains in 3D applications. It supports Windows, Linux, Android, iOS, and MacOS platforms. It's built from ground-up to ensure minimal overhead on the CPU side, providing a more balanced CPU/GPU usage, hence not limiting the game to a single core. Vulkan can be seen as the successor to OpenGL, as it offers lower-level functionality and more efficient multi-threading capabilities.",
+    "links": []
+  },
+  "DvV32n3NoXNEej8Fsqqs2": {
+    "title": "SPIR-V",
+    "description": "`SPIR-V` is a binary intermediate language for graphics and computation kernels, which is defined by the Khronos Group. This programming language has been largely adopted and used by Vulkan, a low-overhead, cross-platform 3D graphics and computing API. Vulkan consumes `SPIR-V` directly, serving as the final shader stage before the GPU. The `SPIR-V` binary format is designed for portability and flexibility, allowing it to be a powerful tool for developers because of its extensibility through the addition of new instructions, without the need to rebuild toolchains or shaders. This makes `SPIR-V` an essential part of Vulkan, especially for game developers creating large, diverse worldscapes and intricate graphics.",
+    "links": []
+  },
+  "Hpf_CPmLpCSP8Qo07Kq1X": {
+    "title": "Game AI",
+    "description": "Game AI is a subfield of artificial intelligence (AI) that is used to create video game characters that act and react like real human players. Game AI is used in a variety of video games, from simple puzzle games to complex strategy games. Game AI can be used to create non-player characters (NPCs) that interact with the player, as well as to create intelligent opponents that challenge the player.",
+    "links": []
+  },
+  "Ky-95ipdgyPZGAIdqwMCk": {
+    "title": "Decision Making",
+    "description": "In game development, decision making often refers to the logic or processes that determine the behavior of non-playable characters or game environments. Three main types of decision making are used: deterministic, stochastic, and strategic. Deterministic decision making is based on predefined rules. With stochastic decision making, outcomes are probability-based, providing an element of randomness. Strategic decision making involves planning a sequence of actions to achieve a specified goal. Decisions can also be guided using various API tools such as **pathfinding algorithms** (which determine the shortest path between two points) or **decision trees** (which facilitate the selection of an action based on certain conditions). The choice of decision-making method depends largely on the desired complexity and behavior of your game elements.",
+    "links": []
+  },
+  "rwGivalwv2ozdSlVMSc4U": {
+    "title": "Decision Tree",
+    "description": "A **Decision Tree** is a graphical representation used in game development which helps to visualize the possible outcomes or paths a game could take depending on certain choices made by a gamer. Each branch of the tree represents a possible decision, outcome, or reaction and each node on the tree represents a game situation or event. Decision Trees help game developers in making strategic designs, create complex enemy AI, and overall assists in predicting the interaction or course of the game. It allows game developers to layout the decision points, possible choices and their outcomes, thus making it easier to trace the direction in which the game progresses.",
+    "links": []
+  },
+  "aJa_2xkZuSjQ5bt6Kj5oe": {
+    "title": "State Machine",
+    "description": "A **State Machine** is a conceptual model that is frequently used in game development to manage game states, or conditions. It consists of a number of different 'states', or modes, and the transitions between them. For instance, a mobile game could have states such as 'Start Screen', 'Playing', 'Paused' and 'Game Over'. Each one of these states will have specific commands associated and rules for transitioning to other states. This will govern the flow and behavior of the game. It can be used in AI character behaviors, UI systems, or game-level states. State Machines keep the code organised and manageable, making it easier for developers to implement complex game logic.",
+    "links": []
+  },
+  "ztoW8fBY73Es624A_tjd7": {
+    "title": "Behavior Tree",
+    "description": "The **Behavior Tree** is a decision-making system used in game development, primarily for AI character behavior. These trees help define the actions an AI character will take, based on predefined tasks and conditions. The tree structure starts from a single root, branching out to nodes that represent these decisions or tasks. The tasks can be simple, such as moving from one point to another, or can be complex decisions like whether to attack or retreat. This kind of structure is advantageous because it is easy to add, remove, or modify tasks without breaking the tree or affecting other tasks. This makes it highly flexible and easy to manage, irrespective of the complexity of the tasks.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Unreal Engine 5 Tutorial - AI Part 2: Behavior Tree",
+        "url": "https://www.youtube.com/watch?v=hbHqv9ov8IM&list=PL4G2bSPE_8uklDwraUCMKHRk2ZiW29R6e&index=3&t=16s",
+        "type": "video"
+      }
+    ]
+  },
+  "4ZCVUpYrCT14d_JULulLe": {
+    "title": "Fuzzy Logic",
+    "description": "Fuzzy Logic is a mathematical logic method that resolves problem-solving and system control. Unlike traditional binary sets (true or false), fuzzy logic variables have a truth value that ranges in degree between 0 and 1. This allows them to handle the concept of partial truth, where the truth value may range between completely true and completely false. In game development, fuzzy logic is often used in artificial intelligence to make the game more realistic. For instance, it can be used to program non-player characters (NPCs) who respond to situational changes dynamically, making the gameplay more engaging and interactive.",
+    "links": []
+  },
+  "c6j-30p84vk3MZEF1R2hN": {
+    "title": "Markov System",
+    "description": "A **Markov System** or **Markov Chain** represents a statistical model that is used in decision-making scenarios within game development. This model is based on the notion of \"memorylessness\" where a certain event's probability depends solely on the state attained in the previous event. It employs a sequence of possible events where the probability of each event hinges on the state achieved in the previous event. A common usage of a Markov System is in designing AI behavior within games, where each state symbolizes a different behavior, and transitions between them are governed by the Markov chain probabilities.",
+    "links": []
+  },
+  "Cuc0xvCAkVyUtwOxO_Uua": {
+    "title": "Goal Oriented Behavior",
+    "description": "Goal oriented behavior in game development refers to the artificial intelligence algorithms employed that give non-player characters (NPCs) the ability to make decisions based on certain objectives or tasks. These NPCs analyze the circumstances in the game environment, formulate a plan to achieve specific goals, and then execute it. The degree of sophistication in these algorithms can range from simple pathways to complex problem-solving solutions. As the behavior models are not hard-coded, it provides NPCs with greater adaptability and autonomy.",
+    "links": []
+  },
+  "mUyzX-DXnIKDl-r9o8d38": {
+    "title": "Movement",
+    "description": "In the context of game development and game API (Application Programming Interface), movement refers to the process of changing the position or orientation of game objects. This involves using programming functions to control objects' movement like walk, run, jump, fly, or any such physical action in the game world. Movement is at the core to creating the dynamics of a game and is critical to both game physics and game logic. Different game engines offer different ways for handling movement. In some APIs, this process could be as simple as setting a new position directly, such as `object.position = new Vector3(5, 10, 0)`. Meanwhile, in others, more complex methods involving real-world physics are required, such as applying forces or altering velocity.",
+    "links": []
+  },
+  "eoK70YRCz73GmzbNhh5kg": {
+    "title": "Board Game",
+    "description": "**Board Games** represent a type of tabletop game that involves counters or pieces moved or placed on a pre-marked surface or \"board\", according to a set of rules. Some games are based on pure strategy, but many contain an element of chance, and others are purely chance, with no element of skill. Games usually have a goal that a player aims to achieve. Early board games represented a battle between two armies, and most modern board games are still based on defeating opponents in terms of counters, winning position, or accruement of points. With the digitalization of board games, developers use various **Game APIs** to create engaging and interactive board game experiences. An API defines a set of rules and protocols for building and interacting with different software applications. Game APIs allow developers to integrate with game-specific features like game mechanics, player statistics, achievements, and more.",
+    "links": []
+  },
+  "oOjGqicW3eqRwWyIwJdBA": {
+    "title": "Minimax",
+    "description": "`Minimax` is an artificial intelligence (AI) decision-making algorithm mainly used in decision making and game theory, particularly for two player zero-sum games. It formulates a strategy by simulating all possible game scenarios and assuming that the opponent is playing an optimal game. Minimax operates by the player minimizing the possible loss for a worst case scenario and thus making the 'maximum of the minimum' possible scenarios. This algorithm is often combined with `alpha-beta pruning` technique to increase its efficiency.",
+    "links": []
+  },
+  "KYCi4d475zZfNwlj6HZVD": {
+    "title": "AB Pruning",
+    "description": "`Alpha-Beta pruning` is an optimization technique for the minimax algorithm used in artificial intelligence (AI) programming, such as game development. It cuts off branches in the game tree that don't need to be searched because there's already a better move available. It uses two parameters, alpha and beta, which represent the minimum score that the maximizing player is assured of and the maximum score that the minimizing player is assured of, respectively. During the traversal of the game tree, branches of the tree that cannot possibly influence the final decision are not explored. This process 'prunes' the minimax tree, saving computational time and resources.",
+    "links": []
+  },
+  "QD9TfZn3yhGPVwiyJ6d0V": {
+    "title": "MCTS",
+    "description": "\"MCTS\", or Monte Carlo Tree Search, is a search algorithm that utilizes methods of decision-making to solve complex problems, commonly implemented in a range of applications, including board games. It essentially operates through building a search tree, node by node, for probable states of a game and then using Monte Carlo simulations to provide a statistical analysis of potential outcomes. It randomly generates moves using the game's determined rules, then makes decisions based on the results of these simulations. In board games, it's often used to determine AI decisions by simulating possible game scenarios, hence contributing to making the AI system more robust and challenging.",
+    "links": []
+  },
+  "Hpk8eOaOepERMmOvUgkxa": {
+    "title": "Game AI",
+    "description": "Game AI is a subfield of artificial intelligence (AI) that is used to create video game characters that act and react like real human players. Game AI is used in a variety of video games, from simple puzzle games to complex strategy games. Game AI can be used to create non-player characters (NPCs) that interact with the player, as well as to create intelligent opponents that challenge the player.",
+    "links": []
+  },
+  "ul5XnVwQCwr4ZaL4kBNpd": {
+    "title": "Decision Learning",
+    "description": "In the realm of game development, **Decision Learning** refers to information systems that recognize and analyze patterns to help in making decisions. It’s particularly used in AI game development where decision-making algorithms or artificial intelligence are programmed to learn from and make decisions based on past experiences or an established decision tree. These decisions can be about game behaviors, player interactions, environment changes and so on. Various methods such as reinforcement learning, Bayesian methods, Decision trees, Neural networks are used to facilitate decision learning in game development.",
+    "links": []
+  },
+  "aw1BAGqrdBBmUwB6vMF_A": {
+    "title": "Naive Bayes Classifier",
+    "description": "The Naive Bayes Classifier is a type of probabalistic machine learning model that is utilized for classification tasks. These tasks can range from email filtering to sentiment analysis or even document categorization. This model is termed 'naive' because it operates under the assumption that each input feature is independent from one another. This simplifying assumption allows for the computation of the probabilities involved to be severely less complicated. It follows the Bayes' Theorem equation to predict the class of the given data point. While this classifier might seem simplistic, it holds its own quite well in complex real-world situations. Due to its simplicity and high efficiency, the Naive Bayes Classifier is one of the most reliable and practical methods in machine learning applications.",
+    "links": []
+  },
+  "sz1047M8_kScjth84yPwU": {
+    "title": "Decision Tree Learning",
+    "description": "`Decision Tree Learning` is an important concept in game development, particularly in the development of artificial intelligence for game characters. It is a kind of machine learning method that is based on using decision tree models to predict or classify information. A decision tree is a flowchart-like model, where each internal node denotes a test on an attribute, each branch represents an outcome of that test, and each leaf node holds a class label (decision made after testing all attributes). By applying decision tree learning models, computer-controlled characters can make decisions based on different conditions or states. They play a key role in creating complex and interactive gameplay experiences, by enabling game characters to adapt to the player's actions and the ever-changing game environment.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Decision trees - A friendly introduction",
+        "url": "https://www.youtube.com/watch?v=HkyWAhr9v8g",
+        "type": "video"
+      }
+    ]
+  },
+  "ltkEyfuDxExs7knqs79ya": {
+    "title": "Deep Learning",
+    "description": "Deep Learning is a sub-field of machine learning, inspired by the structure and function of the human brain, specifically designed to process complex input/output transformations. It uses artificial neural networks with many layers (hence the term 'deep' learning) to model complex, non-linear hypotheses and discover hidden patterns within large datasets. Deep learning techniques are crucial in game development, primarily in creating intelligent behaviors and features in gaming agents, procedural content generation, and player profiling. You might have heard about the uses of deep learning technologies in popular, cutting-edge games like Google DeepMind's AlphaGo. Coding languages like Python, R, and frameworks like TensorFlow, Keras, and PyTorch are commonly used for deep learning tasks. Learning Deep Learning can be a prominent game-changer in your game development journey.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "But what is a neural network? | Chapter 1, Deep learning",
+        "url": "https://www.youtube.com/watch?v=aircAruvnKk",
+        "type": "video"
+      }
+    ]
+  },
+  "AoH2r4EOHyZd8YaV24rBk": {
+    "title": "Artificial Neural Network",
+    "description": "Artificial Neural Networks (ANN) are a branch of machine learning that draw inspiration from biological neural networks. ANNs are capable of 'learning' from observational data, thereby enhancing game development in numerous ways. They consist of interconnected layers of nodes, or artificial neurons, that process information through their interconnected network. Each node's connection has numerical weight that gets adjusted during learning, which helps in optimizing problem solving. ANNs are utilized in various aspects of game development, such as improving AI behavior, procedural content generation, and game testing. They can also be used for image recognition tasks, such as identifying objects or actions in a game environment.",
+    "links": []
+  },
+  "rGEHTfdNeBAX3_XqC-vvI": {
+    "title": "Reinforcements Learning",
+    "description": "`Reinforcement Learning` is a type of Machine Learning which is geared towards making decisions. It involves an agent that learns to behave in an environment, by performing certain actions and observing the results or rewards/results it gets. The main principle of reinforcement learning is to reward good behavior and penalize bad behavior. The agent learns from the consequences of its actions, rather than from being taught explicitly. In the context of game development, reinforcement learning could be used to develop an AI (Artificial Intelligence) which can improve its performance in a game based on reward-driven behavior. The AI gradually learns the optimal strategy, known as policy, to achieve the best result.",
+    "links": [
+      {
+        "title": "AI Learns to Walk (deep reinforcement learning)",
+        "url": "https://m.youtube.com/watch?v=L_4BPjLBF4E",
+        "type": "video"
+      }
+    ]
+  },
+  "9_OcZ9rzedDFfwEYxAghh": {
+    "title": "Learning",
+    "description": "Machine Learning is a field of study that gives computers the ability to learn without being explicitly programmed. It is a branch of artificial intelligence based on the idea that systems can learn from data, identify patterns and make decisions with minimal human intervention. In terms of game development, machine learning can be used to create NPCs that can learn from the player's actions and adapt to them.",
+    "links": []
+  },
+  "CDYszS1U4v95GozB_drbt": {
+    "title": "Advanced Rendering",
+    "description": "**Advanced rendering** is a sophisticated technique used in game development that involves translating a 3D model or scene into a 2D image or animation. Advanced rendering techniques can involve various complex methods such as physically-based rendering, ray tracing, global illumination, subsurface scattering, caustics, and volumetric rendering. The use of advanced rendering can result in highly realistic graphics, as it uses complex calculations to depict how light behaves in the real world. Advanced rendering often requires powerful hardware resources and specialized software tools in order to achieve the desired images and animations.",
+    "links": []
+  },
+  "_i7BXZq-iLxQc3QZRMees": {
+    "title": "Real-time Ray Tracing",
+    "description": "**Real-time Ray Tracing** is a notable advancement in rendering technology. It aims to mimic the way light works in the real world by simulating how each ray of light interacts with different surfaces. In real-time ray tracing, rays of light are generated from the viewer's perspective and sent into the scene. They can reflect off surfaces, refract through materials, or scatter in different directions. These rays can also be absorbed, producing shadows and shaping the visibility of objects. What makes real-time ray tracing special is its ability to calculate all these interactions in real-time, which allows graphics to be much more dynamic and interactive. The complexity of real-time ray tracing involves extensive computational power and it has been a groundbreaking feature in newer hardware and software releases.",
+    "links": []
+  },
+  "qoIkw9o8iMx7MzUyVYoR2": {
+    "title": "DirectX Ray Tracing",
+    "description": "DirectX Ray Tracing (DXR) is an advanced Windows API introduced with DirectX 12. It delivers real-time, cinema-quality rendering to contend development in gaming and professional visualization. It provides highly efficient and straightforward access to RT Core hardware. DXR adds four new concepts to DirectX 12: The acceleration structure, The Raytracing pipeline state object, Shader tables, and the Command list method (DispatchRays). It represents a significant step forward by Microsoft in embracing Ray Tracing as a new standard in real-time rendering pipelines. For developers, DirectX Ray tracing is straightforward to integrate into existing engines given its easy compatibility with existing DirectX 12 programming models. However, to truly maximize DXR's potential, a deep understanding of both graphics workloads and tracing algorithms is necessary.",
+    "links": []
+  },
+  "tDGnV8dGIFr_diz4HcEjr": {
+    "title": "Vulkan Ray Tracing",
+    "description": "`Vulkan Ray Tracing` is an extension of the Vulkan API (Application Programming Interface), which is an open-source, cross-platform API developed by the Khronos Group. Its main goal is to provide developers with greater control over the GPU, enabling better performance and more efficient multisystem and multicore use. The Vulkan Ray Tracing extension provides a standardized ray tracing interface similar to DirectX Raytracing, enabling real-time ray tracing applications to be built on Vulkan. This extension includes a number of functionalities such as acceleration structure building and management, ray tracing shader stages and pipelines, and indirect ray tracing dispatch.",
+    "links": []
+  },
+  "GDLysy3__cbYidEaOmFze": {
+    "title": "OptiX",
+    "description": "`OptiX` is an application framework developed by NVIDIA for achieving high performance ray tracing in graphics processing unit (GPU) programming. It's mainly intended for use in real-time graphics application, scientific simulations, and other visual computing applications. `OptiX` provides key functionalities such as hierarchical object acceleration, programmable ray generation, material shading, and dynamic scene management to achieve fast and state-of-the-art rendering. This highly efficient, scalable and flexible API supports the coding of applications, not just for graphic rendering but also for collision detection and physics simulation. Please note that access to `OptiX` currently requires NVIDIA GeForce, Quadro and Tesla products with Kepler, Maxwell, Pascal, Volta, Turing and later generation GPUs.",
+    "links": []
+  },
+  "XvFtMHrYsBREmuerE7CGc": {
+    "title": "Physically-Based Rendering",
+    "description": "Physically Based Rendering (PBR) is a technique in computer graphics that aims to mimic the interaction of light with surfaces in the real world. It models how light behaves, from reflection to refraction, in a way that accurately represents reality. The PBR model factors in physical properties of materials, such as roughness or metallicity, making the rendering output more consistent and predictable under different lighting conditions. It uses complex shading algorithms and light calculations to generate a high level of realism. In order to achieve this, many PBR systems use a combination of two important components: the Bidirectional Reflectance Distribution Function (BRDF), which defines how light is reflected off an object, and the Bidirectional Surface Scattering Reflectance Distribution Function (BSSRDF), which handles how light scatters under the surface of an object.",
+    "links": []
+  },
+  "PuhXaRZ-Ql5PCqzMyz3en": {
+    "title": "Translucency & Transparency",
+    "description": "In the realm of physically-based rendering, **translucency** and **transparency** act as key aspects in creating visually authentic and compelling images. Transparency refers to the property of an object that allows light to pass through it unhindered, hence making the object clear or invisible. This is commonly seen in materials such as glass, clear plastic, and water. On the other hand, translucency describes how light interacts with a semi-transparent object. Instead of passing directly through, light enters the object, travels within for some distance and then exits at a different location. Common examples of such surfaces include human skin, marble, milk, or wax, which exhibit a soft, diffused lighting effect when light rays pass through them. The technique to achieve this effect in graphics involves subsurface scattering, where incoming light is scattered beneath the object's surface, illuminated it in a way that showcases the material's internal structure.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Learn OpenGL - Blending",
+        "url": "https://learnopengl.com/Advanced-OpenGL/Blending",
+        "type": "article"
+      }
+    ]
+  },
+  "H3hkafXO9zqEnWuwHa38P": {
+    "title": "Conservation of Energy",
+    "description": "In the realm of physically-based rendering, **translucency** and **transparency** act as key aspects in creating visually authentic and compelling images. Transparency refers to the property of an object that allows light to pass through it unhindered, hence making the object clear or invisible. This is commonly seen in materials such as glass, clear plastic, and water. On the other hand, translucency describes how light interacts with a semi-transparent object. Instead of passing directly through, light enters the object, travels within for some distance and then exits at a different location. Common examples of such surfaces include human skin, marble, milk, or wax, which exhibit a soft, diffused lighting effect when light rays pass through them. The technique to achieve this effect in graphics involves subsurface scattering, where incoming light is scattered beneath the object's surface, illuminated it in a way that showcases the material's internal structure.",
+    "links": []
+  },
+  "olY1ibR7kw1yJ58TfU-37": {
+    "title": "Metallicity",
+    "description": "In Physically Based Rendering (PBR), **Metallicity** is a critical property of a material, which influences how it interacts with light. It's a binary property, indicating whether the material is a 'metal' or 'non-metal'. Metals have a high metallicity value (often 1), non-metals (such as wood, plastic, etc.) have a low metallicity value (often 0). Interestingly, with PBR, there exists no 'partially metal' materials ― it's an all or nothing characteristic. This property significantly impacts color handling, too, as metals derive their color from specular reflection while non-metals derive from subsurface scattering (diffuse).",
+    "links": []
+  },
+  "YrQgfjsdLCIUxrwflpEHO": {
+    "title": "Microsurface Scattering",
+    "description": "Microsurface scattering, also known as sub-surface scattering, is an important phenomenon in Physically Based Rendering (PBR). This process involves the penetration of light into the surface of a material, where it is scattered by interacting with the material. In other words, when light strikes an object, rather than simply bouncing off the surface, some of it goes into the object and gets scattered around inside before getting re-emitted. It is key to achieving more realistic rendering of translucent materials like skin, marble, milk, and more. Consider it essential for replicating how light interacts with real-world materials in a convincing manner in your game.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "The 4 main types of subsurface scattering",
+        "url": "https://www.youtube.com/watch?v=GkjvYSbGHg4",
+        "type": "video"
+      }
+    ]
+  }
+}

public/roadmap-content/mlops.json

@@ -0,0 +1,630 @@
+{
+  "_7uvOebQUI4xaSwtMjpEd": {
+    "title": "Programming Fundamentals",
+    "description": "ML programming fundamentals encompass the essential skills and concepts needed to develop machine learning models effectively. Key aspects include understanding data structures and algorithms, as well as proficiency in programming languages commonly used in ML, such as Python and R. Familiarity with libraries and frameworks like TensorFlow, PyTorch, and scikit-learn is crucial for implementing machine learning algorithms and building models. Additionally, concepts such as data preprocessing, feature engineering, model evaluation, and hyperparameter tuning are vital for optimizing performance. A solid grasp of statistics and linear algebra is also important, as these mathematical foundations underpin many ML techniques, enabling practitioners to analyze data and interpret model results accurately.",
+    "links": []
+  },
+  "Vh81GnOUOZvDOlOyI5PwT": {
+    "title": "Python",
+    "description": "Python is an interpreted high-level general-purpose programming language. Its design philosophy emphasizes code readability with its significant use of indentation. Its language constructs as well as its object-oriented approach aim to help programmers write clear, logical code for small and large-scale projects. Python is dynamically-typed and garbage-collected. It supports multiple programming paradigms, including structured (particularly, procedural), object-oriented and functional programming. Python is often described as a \"batteries included\" language due to its comprehensive standard library.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Python Roadmap",
+        "url": "https://roadmap.sh/python",
+        "type": "article"
+      },
+      {
+        "title": "Python.org",
+        "url": "https://www.python.org/",
+        "type": "article"
+      },
+      {
+        "title": "Real Python",
+        "url": "https://realpython.com/",
+        "type": "article"
+      },
+      {
+        "title": "Automate the Boring Stuff with Python",
+        "url": "https://automatetheboringstuff.com/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Python",
+        "url": "https://app.daily.dev/tags/python?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "vdVq3RQvQF3mF8PQc6DMg": {
+    "title": "Go",
+    "description": "Go, also known as Golang, is an open-source programming language developed by Google that emphasizes simplicity, efficiency, and strong concurrency support. Designed for modern software development, Go features a clean syntax, garbage collection, and built-in support for concurrent programming through goroutines and channels, making it well-suited for building scalable, high-performance applications, especially in cloud computing and microservices architectures. Go's robust standard library and tooling ecosystem, including a powerful package manager and testing framework, further streamline development processes, promoting rapid application development and deployment. Visit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Visit Dedicated Go Roadmap",
+        "url": "https://roadmap.sh/golang",
+        "type": "article"
+      },
+      {
+        "title": "A Tour of Go – Go Basics",
+        "url": "https://go.dev/tour/welcome/1",
+        "type": "article"
+      },
+      {
+        "title": "Go Reference Documentation",
+        "url": "https://go.dev/doc/",
+        "type": "article"
+      },
+      {
+        "title": "Making a RESTful JSON API in Go",
+        "url": "https://thenewstack.io/make-a-restful-json-api-go/",
+        "type": "article"
+      },
+      {
+        "title": "Go, the Programming Language of the Cloud",
+        "url": "https://thenewstack.io/go-the-programming-language-of-the-cloud/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Golang",
+        "url": "https://app.daily.dev/tags/golang?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Go Programming Course",
+        "url": "https://www.youtube.com/watch?v=un6ZyFkqFKo",
+        "type": "video"
+      }
+    ]
+  },
+  "mMzqJF2KQ49TDEk5F3VAI": {
+    "title": "Bash",
+    "description": "Bash (Bourne Again Shell) is a Unix shell and command language used for interacting with the operating system through a terminal. It allows users to execute commands, automate tasks via scripting, and manage system operations. As the default shell for many Linux distributions, it supports command-line utilities, file manipulation, process control, and text processing. Bash scripts can include loops, conditionals, and functions, making it a powerful tool for system administration, automation, and task scheduling.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "bash-guide",
+        "url": "https://github.com/Idnan/bash-guide",
+        "type": "opensource"
+      },
+      {
+        "title": "Bash Scripting Course",
+        "url": "https://www.youtube.com/watch?v=tK9Oc6AEnR4",
+        "type": "video"
+      }
+    ]
+  },
+  "oUhlUoWQQ1txx_sepD5ev": {
+    "title": "Version Control Systems",
+    "description": "Version control/source control systems allow developers to track and control changes to code over time. These services often include the ability to make atomic revisions to code, branch/fork off of specific points, and to compare versions of code. They are useful in determining the who, what, when, and why code changes were made.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Git",
+        "url": "https://git-scm.com/",
+        "type": "article"
+      },
+      {
+        "title": "What is Version Control?",
+        "url": "https://www.atlassian.com/git/tutorials/what-is-version-control",
+        "type": "article"
+      }
+    ]
+  },
+  "06T5CbZAGJU6fJhCmqCC8": {
+    "title": "Git",
+    "description": "Git is a distributed version control system used to track changes in source code during software development. It enables multiple developers to collaborate on a project by managing versions of code, allowing for branching, merging, and tracking of revisions. Git ensures that changes are recorded with a complete history, enabling rollback to previous versions if necessary. It supports distributed workflows, meaning each developer has a complete local copy of the project’s history, facilitating seamless collaboration, conflict resolution, and efficient management of code across different teams or environments.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Learn Git & GitHub",
+        "url": "https://roadmap.sh/git-github",
+        "type": "article"
+      },
+      {
+        "title": "Learn Git with Tutorials, News and Tips - Atlassian",
+        "url": "https://www.atlassian.com/git",
+        "type": "article"
+      },
+      {
+        "title": "Git Cheat Sheet",
+        "url": "https://cs.fyi/guide/git-cheatsheet",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Git",
+        "url": "https://app.daily.dev/tags/git?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Git & GitHub Crash Course For Beginners",
+        "url": "https://www.youtube.com/watch?v=SWYqp7iY_Tc",
+        "type": "video"
+      }
+    ]
+  },
+  "7t7jSb3YgyWlhgCe8Se1I": {
+    "title": "GitHub",
+    "description": "GitHub is a web-based platform built on top of Git that provides version control, collaboration tools, and project management features for software development. It enables developers to host Git repositories, collaborate on code through pull requests, and review and track changes. GitHub also offers additional features like issue tracking, continuous integration, automated workflows, and documentation hosting. With its social coding environment, GitHub fosters open-source contributions and team collaboration, making it a central hub for many software development projects.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Learn Git & GitHub",
+        "url": "https://roadmap.sh/git-github",
+        "type": "article"
+      },
+      {
+        "title": "GitHub Website",
+        "url": "https://github.com",
+        "type": "article"
+      },
+      {
+        "title": "GitHub Documentation",
+        "url": "https://docs.github.com/en/get-started/quickstart",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about GitHub",
+        "url": "https://app.daily.dev/tags/github?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "What is GitHub?",
+        "url": "https://www.youtube.com/watch?v=w3jLJU7DT5E",
+        "type": "video"
+      }
+    ]
+  },
+  "00GZcwe25QYi7rDzaOoMt": {
+    "title": "Cloud Computing",
+    "description": "**Cloud Computing** refers to the delivery of computing services over the internet rather than using local servers or personal devices. These services include servers, storage, databases, networking, software, analytics, and intelligence. Cloud Computing enables faster innovation, flexible resources, and economies of scale. There are various types of cloud computing such as public clouds, private clouds, and hybrids clouds. Furthermore, it's divided into different services like Infrastructure as a Service (IaaS), Platform as a Service (PaaS), and Software as a Service (SaaS). These services differ mainly in the level of control an organization has over their data and infrastructures.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is cloud computing?",
+        "url": "https://azure.microsoft.com/en-gb/resources/cloud-computing-dictionary/what-is-cloud-computing",
+        "type": "article"
+      },
+      {
+        "title": "What is Cloud Computing? | Amazon Web Services",
+        "url": "https://www.youtube.com/watch?v=mxT233EdY5c",
+        "type": "video"
+      }
+    ]
+  },
+  "u3E7FGW4Iwdsu61KYFxCX": {
+    "title": "AWS / Azure / GCP",
+    "description": "AWS (Amazon Web Services) Azure and GCP (Google Cloud Platform) are three leading providers of cloud computing services. AWS by Amazon is the oldest and the most established among the three, providing a breadth and depth of solutions ranging from infrastructure services like compute, storage, and databases to the machine and deep learning. Azure, by Microsoft, has integrated tools for DevOps, supports a large number of programming languages, and offers seamless integration with on-prem servers and Microsoft’s software. Google's GCP has strength in cost-effectiveness, live migration of virtual machines, and flexible computing options. All three have introduced various MLOps tools and services to boost capabilities for machine learning development and operations.\n\nVisit the following resources to learn more about AWS, Azure, and GCP:",
+    "links": [
+      {
+        "title": "AWS Roadmap",
+        "url": "https://roadmap.sh/aws",
+        "type": "article"
+      },
+      {
+        "title": "Azure Tutorials",
+        "url": "https://docs.microsoft.com/en-us/learn/azure/",
+        "type": "article"
+      },
+      {
+        "title": "GCP Learning Resources",
+        "url": "https://cloud.google.com/training",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about AWS",
+        "url": "https://app.daily.dev/tags/aws?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "kbfucfIO5KCsuv3jKbHTa": {
+    "title": "Cloud-native ML Services",
+    "description": "Most of the cloud providers offer managed services for machine learning. These services are designed to help data scientists and machine learning engineers to build, train, and deploy machine learning models at scale. These services are designed to be cloud-native, meaning they are designed to work with other cloud services and are optimized for the cloud environment.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "AWS Sage Maker",
+        "url": "https://aws.amazon.com/sagemaker/",
+        "type": "article"
+      },
+      {
+        "title": "Azure ML",
+        "url": "https://azure.microsoft.com/en-gb/products/machine-learning",
+        "type": "article"
+      },
+      {
+        "title": "What is Cloud Native?",
+        "url": "https://www.youtube.com/watch?v=fp9_ubiKqFU",
+        "type": "video"
+      }
+    ]
+  },
+  "tKeejLv8Q7QX40UtOjpav": {
+    "title": "Containerization",
+    "description": "Containers are a construct in which cgroups, namespaces, and chroot are used to fully encapsulate and isolate a process. This encapsulated process, called a container image, shares the kernel of the host with other containers, allowing containers to be significantly smaller and faster than virtual machines.\n\nThese images are designed for portability, allowing for full local testing of a static image, and easy deployment to a container management platform.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "What are Containers?",
+        "url": "https://cloud.google.com/learn/what-are-containers",
+        "type": "article"
+      },
+      {
+        "title": "What is a Container?",
+        "url": "https://www.docker.com/resources/what-container/",
+        "type": "article"
+      },
+      {
+        "title": "Articles about Containers - The New Stack",
+        "url": "https://thenewstack.io/category/containers/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Containers",
+        "url": "https://app.daily.dev/tags/containers?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "What are Containers?",
+        "url": "https://www.youtube.com/playlist?list=PLawsLZMfND4nz-WDBZIj8-nbzGFD4S9oz",
+        "type": "video"
+      }
+    ]
+  },
+  "XIdCvT-4HyyglHJLRrHlz": {
+    "title": "Docker",
+    "description": "Docker is a platform for working with containerized applications. Among its features are a daemon and client for managing and interacting with containers, registries for storing images, and a desktop application to package all these features together.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Docker Documentation",
+        "url": "https://docs.docker.com/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Docker",
+        "url": "https://app.daily.dev/tags/docker?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Docker Tutorial",
+        "url": "https://www.youtube.com/watch?v=RqTEHSBrYFw",
+        "type": "video"
+      },
+      {
+        "title": "Docker simplified in 55 seconds",
+        "url": "https://youtu.be/vP_4DlOH1G4",
+        "type": "video"
+      }
+    ]
+  },
+  "XQoK9l-xtN2J8ZV8dw53X": {
+    "title": "Kubernetes",
+    "description": "Kubernetes is an open source container management platform, and the dominant product in this space. Using Kubernetes, teams can deploy images across multiple underlying hosts, defining their desired availability, deployment logic, and scaling logic in YAML. Kubernetes evolved from Borg, an internal Google platform used to provision and allocate compute resources (similar to the Autopilot and Aquaman systems of Microsoft Azure). The popularity of Kubernetes has made it an increasingly important skill for the DevOps Engineer and has triggered the creation of Platform teams across the industry. These Platform engineering teams often exist with the sole purpose of making Kubernetes approachable and usable for their product development colleagues.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Kubernetes Roadmap",
+        "url": "https://roadmap.sh/kubernetes",
+        "type": "article"
+      },
+      {
+        "title": "Kubernetes Website",
+        "url": "https://kubernetes.io/",
+        "type": "article"
+      },
+      {
+        "title": "Kubernetes Documentation",
+        "url": "https://kubernetes.io/docs/home/",
+        "type": "article"
+      },
+      {
+        "title": "Kubernetes: An Overview",
+        "url": "https://thenewstack.io/kubernetes-an-overview/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Kubernetes",
+        "url": "https://app.daily.dev/tags/kubernetes?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Kubernetes Crash Course for Absolute Beginners",
+        "url": "https://www.youtube.com/watch?v=s_o8dwzRlu4",
+        "type": "video"
+      }
+    ]
+  },
+  "ulka7VEVjz6ls5SnI6a6z": {
+    "title": "Machine Learning Fundamentals",
+    "description": "Machine learning fundamentals encompass the key concepts and techniques that enable systems to learn from data and make predictions or decisions without being explicitly programmed. At its core, machine learning involves algorithms that can identify patterns in data and improve over time with experience. Key areas include supervised learning (where models are trained on labeled data), unsupervised learning (where models identify patterns in unlabeled data), and reinforcement learning (where agents learn to make decisions based on feedback from their actions). Essential components also include data preprocessing, feature selection, model training, evaluation metrics, and the importance of avoiding overfitting. Understanding these fundamentals is crucial for developing effective machine learning applications across various domains. Learn more from the following resources:",
+    "links": [
+      {
+        "title": "Fundamentals of Machine Learning - Microsoft",
+        "url": "https://learn.microsoft.com/en-us/training/modules/fundamentals-machine-learning/",
+        "type": "course"
+      },
+      {
+        "title": "MLCourse.ai",
+        "url": "https://mlcourse.ai/",
+        "type": "course"
+      },
+      {
+        "title": "Fast.ai",
+        "url": "https://course.fast.ai",
+        "type": "course"
+      }
+    ]
+  },
+  "VykbCu7LWIx8fQpqKzoA7": {
+    "title": "Data Engineering Fundamentals",
+    "description": "Data Engineering is essentially dealing with the collection, validation, storage, transformation, and processing of data. The objective is to provide reliable, efficient, and scalable data pipelines and infrastructure that allow data scientists to convert data into actionable insights. It involves steps like data ingestion, data storage, data processing, and data provisioning. Important concepts include designing, building, and maintaining data architecture, databases, processing systems, and large-scale processing systems. It is crucial to have extensive technical knowledge in various tools and programming languages like SQL, Python, Hadoop, and more.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Data Engineering 101",
+        "url": "https://www.redpanda.com/guides/fundamentals-of-data-engineering",
+        "type": "article"
+      },
+      {
+        "title": "Fundamentals of Data Engineering",
+        "url": "https://www.youtube.com/watch?v=mPSzL8Lurs0",
+        "type": "video"
+      }
+    ]
+  },
+  "cOg3ejZRYE-u-M0c89IjM": {
+    "title": "Data Pipelines",
+    "description": "Data pipelines are a series of automated processes that transport and transform data from various sources to a destination for analysis or storage. They typically involve steps like data extraction, cleaning, transformation, and loading (ETL) into databases, data lakes, or warehouses. Pipelines can handle batch or real-time data, ensuring that large-scale datasets are processed efficiently and consistently. They play a crucial role in ensuring data integrity and enabling businesses to derive insights from raw data for reporting, analytics, or machine learning.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is a data pipeline?",
+        "url": "https://www.ibm.com/topics/data-pipeline",
+        "type": "article"
+      },
+      {
+        "title": "What are data pipelines?",
+        "url": "https://www.youtube.com/watch?v=oKixNpz6jNo",
+        "type": "video"
+      }
+    ]
+  },
+  "wOogVDV4FIDLXVPwFqJ8C": {
+    "title": "Data Lakes & Warehouses",
+    "description": "\"**Data Lakes** are large-scale data repository systems that store raw, untransformed data, in various formats, from multiple sources. They're often used for big data and real-time analytics requirements. Data lakes preserve the original data format and schema which can be modified as necessary. On the other hand, **Data Warehouses** are data storage systems which are designed for analyzing, reporting and integrating with transactional systems. The data in a warehouse is clean, consistent, and often transformed to meet wide-range of business requirements. Hence, data warehouses provide structured data but require more processing and management compared to data lakes.\"\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Data lake definition",
+        "url": "https://azure.microsoft.com/en-gb/resources/cloud-computing-dictionary/what-is-a-data-lake",
+        "type": "article"
+      },
+      {
+        "title": "What is a data lake?",
+        "url": "https://www.youtube.com/watch?v=LxcH6z8TFpI",
+        "type": "video"
+      },
+      {
+        "title": "@hat is a data warehouse?",
+        "url": "https://www.youtube.com/watch?v=k4tK2ttdSDg",
+        "type": "video"
+      }
+    ]
+  },
+  "Berd78HvnulNEGOsHCf8n": {
+    "title": "Data Ingestion Architecture",
+    "description": "Data ingestion is the process of collecting, transferring, and loading data from various sources to a destination where it can be stored and analyzed. There are several data ingestion architectures that can be used to collect data from different sources and load it into a data warehouse, data lake, or other storage systems. These architectures can be broadly classified into two categories: batch processing and real-time processing. How you choose to ingest data will depend on the volume, velocity, and variety of data you are working with, as well as the latency requirements of your use case.\n\nLambda and Kappa architectures are two popular data ingestion architectures that combine batch and real-time processing to handle large volumes of data efficiently.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Data Ingestion Patterns",
+        "url": "https://docs.aws.amazon.com/whitepapers/latest/aws-cloud-data-ingestion-patterns-practices/data-ingestion-patterns.html",
+        "type": "article"
+      },
+      {
+        "title": "What is a data pipeline?",
+        "url": "https://www.youtube.com/watch?v=kGT4PcTEPP8",
+        "type": "video"
+      }
+    ]
+  },
+  "pVSlVHXIap0unFxLGM-lQ": {
+    "title": "Airflow",
+    "description": "Airflow is a platform to programmatically author, schedule and monitor workflows. Use airflow to author workflows as directed acyclic graphs (DAGs) of tasks. The airflow scheduler executes your tasks on an array of workers while following the specified dependencies. Rich command line utilities make performing complex surgeries on DAGs a snap. The rich user interface makes it easy to visualize pipelines running in production, monitor progress, and troubleshoot issues when needed. When workflows are defined as code, they become more maintainable, versionable, testable, and collaborative.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Airflow website",
+        "url": "https://airflow.apache.org/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Apache Airflow",
+        "url": "https://app.daily.dev/tags/apache-airflow?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "UljuqA89_SlCSDWWMD_C_": {
+    "title": "Spark",
+    "description": "Apache Spark is an open-source distributed computing system designed for big data processing and analytics. It offers a unified interface for programming entire clusters, enabling efficient handling of large-scale data with built-in support for data parallelism and fault tolerance. Spark excels in processing tasks like batch processing, real-time data streaming, machine learning, and graph processing. It’s known for its speed, ease of use, and ability to process data in-memory, significantly outperforming traditional MapReduce systems. Spark is widely used in big data ecosystems for its scalability and versatility across various data processing tasks.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "ApacheSpark",
+        "url": "https://spark.apache.org/documentation.html",
+        "type": "article"
+      },
+      {
+        "title": "Spark By Examples",
+        "url": "https://sparkbyexamples.com",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Apache Spark",
+        "url": "https://app.daily.dev/tags/spark?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "fMNwzhgLgHlAZJ9NvKikR": {
+    "title": "Kafka",
+    "description": "Apache Kafka is an open-source distributed event streaming platform used by thousands of companies for high-performance data pipelines, streaming analytics, data integration, and mission-critical applications.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Apache Kafka quickstart",
+        "url": "https://kafka.apache.org/quickstart",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Kafka",
+        "url": "https://app.daily.dev/tags/kafka?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Apache Kafka Fundamentals",
+        "url": "https://www.youtube.com/watch?v=B5j3uNBH8X4",
+        "type": "video"
+      }
+    ]
+  },
+  "o6GQ3-8DgDtHzdX6yeg1w": {
+    "title": "Flink",
+    "description": "Apache Flink is an open-source stream processing framework designed for real-time and batch data processing with low latency and high throughput. It supports event time processing, fault tolerance, and stateful operations, making it ideal for applications like real-time analytics, fraud detection, and event-driven systems. Flink is highly scalable, integrates with various data systems, and is widely used in industries for large-scale, real-time data processing tasks.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Apache Flink Documentation",
+        "url": "https://flink.apache.org/",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Apache Flink",
+        "url": "https://app.daily.dev/tags/apache-flink?ref=roadmapsh",
+        "type": "article"
+      },
+      {
+        "title": "Apache Flink Tutorialpoint",
+        "url": "https://www.tutorialspoint.com/apache_flink/apache_flink_introduction.htm",
+        "type": "article"
+      }
+    ]
+  },
+  "iTsEHVCo6KGq7H2HMgy5S": {
+    "title": "MLOps Principles",
+    "description": "MLOps (Machine Learning Operations) principles focus on streamlining the deployment, monitoring, and management of machine learning models in production environments. Key principles include:\n\n1.  **Collaboration**: Foster collaboration between data scientists, developers, and operations teams to ensure alignment on model goals, performance, and lifecycle management.\n    \n2.  **Automation**: Automate workflows for model training, testing, deployment, and monitoring to enhance efficiency, reduce errors, and speed up the development lifecycle.\n    \n3.  **Version Control**: Implement version control for both code and data to track changes, reproduce experiments, and maintain model lineage.\n    \n4.  **Continuous Integration and Deployment (CI/CD)**: Establish CI/CD pipelines tailored for machine learning to facilitate rapid model iteration and deployment.\n    \n5.  **Monitoring and Governance**: Continuously monitor model performance and data drift in production to ensure models remain effective and compliant with regulatory requirements.\n    \n6.  **Scalability**: Design systems that can scale to handle varying workloads and accommodate changes in data volume and complexity.\n    \n7.  **Reproducibility**: Ensure that experiments can be reliably reproduced by standardizing environments and workflows, making it easier to validate and iterate on models.\n    \n\nThese principles help organizations efficiently manage the lifecycle of machine learning models, from development to deployment and beyond.",
+    "links": []
+  },
+  "l1xasxQy2vAY34NWaqKEe": {
+    "title": "MLOps Components",
+    "description": "MLOps components can be broadly classified into three major categories: Development, Operations and Governance. The **Development** components include everything involved in the creation of machine learning models, such as data extraction, data analysis, feature engineering, and machine learning model training. The **Operations** category includes components involved in deploying, monitoring, and maintaining machine learning models in production. This may include release management, model serving, and performance monitoring. Lastly, the **Governance** category encompasses the policies and regulations related to machine learning models. This includes model audit and tracking, model explainability, and security & compliance regulations.",
+    "links": []
+  },
+  "kHDSwlSq8WkLey4EJIQSR": {
+    "title": "Version Control",
+    "description": "Version control/source control systems allow developers to track and control changes to code over time. These services often include the ability to make atomic revisions to code, branch/fork off of specific points, and to compare versions of code. They are useful in determining the who, what, when, and why code changes were made.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Git",
+        "url": "https://git-scm.com/",
+        "type": "article"
+      },
+      {
+        "title": "What is Version Control?",
+        "url": "https://www.atlassian.com/git/tutorials/what-is-version-control",
+        "type": "article"
+      },
+      {
+        "title": "Explore top posts about Version Control",
+        "url": "https://app.daily.dev/tags/version-control?ref=roadmapsh",
+        "type": "article"
+      }
+    ]
+  },
+  "a6vawajw7BpL6plH_nuAz": {
+    "title": "CI/CD",
+    "description": "CI/CD (Continuous Integration and Continuous Deployment/Delivery) is a software development practice that automates the process of integrating code changes, running tests, and deploying updates. Continuous Integration focuses on regularly merging code changes into a shared repository, followed by automated testing to ensure code quality. Continuous Deployment extends this by automatically releasing every validated change to production, while Continuous Delivery ensures code is always in a deployable state, but requires manual approval for production releases. CI/CD pipelines improve code reliability, reduce integration risks, and speed up the development lifecycle.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is CI/CD?",
+        "url": "https://www.redhat.com/en/topics/devops/what-is-ci-cd",
+        "type": "article"
+      },
+      {
+        "title": "CI/CD In 5 Minutes",
+        "url": "https://www.youtube.com/watch?v=42UP1fxi2SY",
+        "type": "video"
+      }
+    ]
+  },
+  "fes7M--Y8i08_zeP98tVV": {
+    "title": "Orchestration",
+    "description": "ML orchestration refers to the process of managing and coordinating the various tasks and workflows involved in the machine learning lifecycle, from data preparation and model training to deployment and monitoring. It involves integrating multiple tools and platforms to streamline operations, automate repetitive tasks, and ensure seamless collaboration among data scientists, engineers, and operations teams. By using orchestration frameworks, organizations can enhance reproducibility, scalability, and efficiency, enabling them to manage complex machine learning pipelines and improve the overall quality of models in production. This ensures that models are consistently updated and maintained, facilitating rapid iteration and adaptation to changing data and business needs.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "ML Observability: what, why, how",
+        "url": "https://ubuntu.com/blog/ml-observability",
+        "type": "article"
+      }
+    ]
+  },
+  "fGGWKmAJ50Ke6wWJBEgby": {
+    "title": "Experiment Tracking & Model Registry",
+    "description": "**Experiment Tracking** is an essential part of MLOps, providing a system to monitor and record the different experiments conducted during the machine learning model development process. This involves capturing, organizing and visualizing the metadata associated with each experiment, such as hyperparameters used, models produced, metrics like accuracy or loss, and other information about the computational environment. This tracking allows for reproducibility of experiments, comparison across different experiment runs, and helps in identifying the best models.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Experiment Tracking",
+        "url": "https://madewithml.com/courses/mlops/experiment-tracking/#dashboard",
+        "type": "article"
+      },
+      {
+        "title": "ML Flow Model Registry",
+        "url": "https://mlflow.org/docs/latest/model-registry.html",
+        "type": "article"
+      }
+    ]
+  },
+  "6XgP_2NLuiw654zvTyueT": {
+    "title": "Data Lineage & Feature Stores",
+    "description": "**Data Lineage** refers to the life-cycle of data, including its origins, movements, characteristics and quality. It's a critical component in MLOps for tracking the journey of data through every process in a pipeline, from raw input to model output. Data lineage helps in maintaining transparency, ensuring compliance, and facilitating data debugging or tracing data related bugs. It provides a clear representation of data sources, transformations, and dependencies thereby aiding in audits, governance, or reproduction of machine learning models.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is Data Lineage?",
+        "url": "https://www.ibm.com/topics/data-lineage",
+        "type": "article"
+      },
+      {
+        "title": "What is a feature store",
+        "url": "https://www.snowflake.com/guides/what-feature-store-machine-learning/",
+        "type": "article"
+      }
+    ]
+  },
+  "zsW1NRb0dMgS-KzWsI0QU": {
+    "title": "Model Training & Serving",
+    "description": "\"Model Training\" refers to the phase in the Machine Learning (ML) pipeline where we teach a machine learning model how to make predictions by providing it with data. This process begins with feeding the model a training dataset, which it uses to learn and understand patterns or perform computations. The model's performance is then evaluated by comparing its prediction outputs with the actual results. Various algorithms can be used in the model training process. The choice of algorithm usually depends on the task, the data available, and the requirements of the project. It is worth noting that the model training stage can be computationally expensive particularly when dealing with large datasets or complex models.\n\nDecisions depend on the organization's infrastructure.\n\n*   **Repository Suggestion:** [ML Deployment k8s Fast API](https://github.com/sayakpaul/ml-deployment-k8s-fastapi/tree/main)\n*   **Tutorial Suggestions:** [ML deployment with k8s FastAPI, Building an ML app with FastAPI](https://dev.to/bravinsimiyu/beginner-guide-on-how-to-build-a-machine-learning-app-with-fastapi-part-ii-deploying-the-fastapi-application-to-kubernetes-4j6g), [Basic Kubeflow pipeline](https://towardsdatascience.com/tutorial-basic-kubeflow-pipeline-from-scratch-5f0350dc1905), [Building and deploying ML pipelines](https://www.datacamp.com/tutorial/kubeflow-tutorial-building-and-deploying-machine-learning-pipelines?utm_source=google&utm_medium=paid_search&utm_campaignid=19589720818&utm_adgroupid=157156373991&utm_device=c&utm_keyword=&utm_matchtype=&utm_network=g&utm_adpostion=&utm_creative=683184494153&utm_targetid=dsa-2218886984380&utm_loc_interest_ms=&utm_loc_physical_ms=9064564&utm_content=&utm_campaign=230119_1-sea~dsa~tofu_2-b2c_3-eu_4-prc_5-na_6-na_7-le_8-pdsh-go_9-na_10-na_11-na-dec23&gad_source=1&gclid=Cj0KCQiA4Y-sBhC6ARIsAGXF1g7iSih9h2RGL27LwWY6dlPLhEss-e5Af8pnaBvdDynRh7IHIKi8sGgaApD-EALw_wcB), [KServe tutorial](https://towardsdatascience.com/kserve-highly-scalable-machine-learning-deployment-with-kubernetes-aa7af0b71202)",
+    "links": []
+  },
+  "r4fbUwD83uYumEO1X8f09": {
+    "title": "Monitoring & Observability",
+    "description": "**Monitoring** in MLOps primarily involves tracking the performance of machine learning (ML) models in production to ensure that they continually deliver accurate and reliable results. Such monitoring is necessary because the real-world data that these models handle may change over time, a scenario known as data drift. These changes can adversely affect model performance. Monitoring helps to detect any anomalies in the model’s behaviour or performance and such alerts can trigger the retraining of models with new data. From a broader perspective, monitoring also involves tracking resources and workflows to detect and rectify any operational issues in the MLOps pipeline.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "ML Monitoring vs ML Observability",
+        "url": "https://medium.com/marvelous-mlops/ml-monitoring-vs-ml-observability-understanding-the-differences-fff574a8974f",
+        "type": "article"
+      },
+      {
+        "title": "ML Observability vs ML Monitoring: What's the difference?",
+        "url": "https://www.youtube.com/watch?v=k1Reed3QIYE",
+        "type": "video"
+      }
+    ]
+  },
+  "sf67bSL7HAx6iN7S6MYKs": {
+    "title": "Infrastructure as Code",
+    "description": "Infrastructure as Code (IaC) is a modern approach to managing and provisioning IT infrastructure through machine-readable configuration files, rather than manual processes. It enables developers and operations teams to define and manage infrastructure resources—such as servers, networks, and databases—using code, which can be versioned, tested, and deployed like application code. IaC tools, like Terraform and AWS CloudFormation, allow for automated, repeatable deployments, reducing human error and increasing consistency across environments. This practice facilitates agile development, enhances collaboration between teams, and supports scalable and efficient infrastructure management.",
+    "links": [
+      {
+        "title": "What is Infrastructure as Code?",
+        "url": "https://www.redhat.com/en/topics/automation/what-is-infrastructure-as-code-iac",
+        "type": "article"
+      },
+      {
+        "title": "Terraform course for beginners",
+        "url": "https://www.youtube.com/watch?v=SLB_c_ayRMo",
+        "type": "video"
+      },
+      {
+        "title": "8 Terraform best practices",
+        "url": "https://www.youtube.com/watch?v=gxPykhPxRW0",
+        "type": "video"
+      }
+    ]
+  }
+}

public/roadmap-content/product-manager.json

@@ -0,0 +1,930 @@
+{
+  "luk1vnpy0duneVjen8WzO": {
+    "title": "What is Product Management?",
+    "description": "Product management is a multifaceted discipline that forms the backbone of any technology organization. As a product manager, individuals are responsible for guiding the success of a product and leading the cross-functional team that is responsible for improving it. This entails an understanding of the market, the competitive landscape, customer demand and preferences, as well as business strategy. The decisions made by the product manager directly influence the strategic direction, design, functionality, and commercial success of the product. They essentially form a bridge between different teams, such as engineering, design, marketing, sales, and customer support, ensuring a seamless transition from product development to product release.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is Product Management? - Product Plan",
+        "url": "https://www.productplan.com/learn/what-is-product-management/#what-is-product-management",
+        "type": "article"
+      },
+      {
+        "title": "What is Product Management? - Atlassian",
+        "url": "https://www.youtube.com/watch?v=kzMBIyzq9Ag",
+        "type": "video"
+      }
+    ]
+  },
+  "V-IeFB9S2tToxANHIzpMs": {
+    "title": "Product vs Project Management",
+    "description": "Project management focuses on planning, executing, and closing specific projects with defined objectives, timelines, and deliverables, ensuring that tasks are completed on time and within budget. It is concerned with the successful completion of a project, often involving temporary endeavors with a clear beginning and end. In contrast, product management is a continuous process that involves the entire lifecycle of a product, from ideation and development to market launch and ongoing improvements.\n\nProduct managers are responsible for defining the product vision, strategy, and roadmap, ensuring that the product meets customer needs and business goals. They work cross-functionally with teams like engineering, marketing, and sales to deliver a product that provides value over its entire lifecycle. While project managers focus on the execution of specific initiatives, product managers concentrate on the long-term success and evolution of a product.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Product vs Project Manager - Coursera",
+        "url": "https://www.coursera.org/gb/articles/product-manager-vs-project-manager",
+        "type": "article"
+      },
+      {
+        "title": "Product Manager vs Project Manager",
+        "url": "https://www.youtube.com/watch?v=nPR6HsUO_XY",
+        "type": "video"
+      }
+    ]
+  },
+  "Dx6ee8P_Agpw1MLKlAPGI": {
+    "title": "Roles and Responsibilities",
+    "description": "A product manager is a pivotal role that stands at the crossroads of business, technology, and user experience aspects. Their roles and responsibilities include understanding customer needs, defining and communicating product strategy, prioritizing product features, liaising with different teams such as engineering, sales and marketing to ensure seamless product development and launch, monitoring and analyzing market trends, and ultimately driving the success of the product in the market. A prodigious product manager, with a unique blend of business acuity and technical knack, can significantly impact the product's acceptance in the market and the company's bottom line.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Product Manager Roles & Responsibilities",
+        "url": "https://www.productside.com/product-manager-roles-and-responsibilities-keytask/",
+        "type": "article"
+      }
+    ]
+  },
+  "5W-3jh1-4qSU5kagrWv9z": {
+    "title": "Key Skills",
+    "description": "A Product Manager is often viewed as the \"CEO of the Product\", requiring a unique blend of business, technical, and strategic skills to drive the product's success. Core competencies for a Product Manager typically include strategic thinking, the ability to influence cross-functional teams, technical proficiency, understanding of customer needs and market trends, problem-solving abilities, and exceptional communication skills. These key skills are vital in managing stakeholders, formulating strategic product vision, making crucial business decisions, and ensuring seamless product execution. The ability to continuously learn and adapt is also crucial due to the dynamic nature of the product management industry.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What Skills Does a Product Manager Need?",
+        "url": "https://careerfoundry.com/en/blog/product-management/product-manager-skills/",
+        "type": "article"
+      },
+      {
+        "title": "Skills Every Product Manager Needs",
+        "url": "https://www.youtube.com/watch?v=ysBpePyeHkU",
+        "type": "video"
+      }
+    ]
+  },
+  "kB8e26BUm8BpTY1_O3N3_": {
+    "title": "Product Development Lifecycle",
+    "description": "The Product Development Lifecycle is a crucial aspect for Product Managers to understand. It represents the systematic and methodical journey a product takes from conceptual idea to market distribution. This lifecycle consists of several distinct stages such as ideation, design, development, testing, and launch. Developing a thorough comprehension of this process enables Product Managers to effectively manage, predict and strategize around the potential challenges and opportunities each stage presents. This understanding is vital for successful product launches, maximizing product potential, and ensuring alignment with market demands and customer expectations.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Product Development Lifecycle - MailChimp",
+        "url": "https://mailchimp.com/resources/product-life-cycle/",
+        "type": "article"
+      }
+    ]
+  },
+  "5okUFVMuG6mjRki4fyCcF": {
+    "title": "Development",
+    "description": "The development phase of the product development lifecycle is a critical stage where ideas transform into tangible products. For product managers, this phase involves coordinating with cross-functional teams, including engineering, design, and quality assurance, to ensure that the product meets its specifications and market requirements. This phase focuses on building, testing, and refining the product, incorporating feedback from iterative testing and addressing any technical challenges that arise. Effective management during this stage is essential for aligning the product with its strategic goals and preparing it for a successful launch.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "What is Product Development?",
+        "url": "https://www.aha.io/roadmapping/guide/what-is-product-development",
+        "type": "article"
+      },
+      {
+        "title": "What's Product Development?",
+        "url": "https://www.youtube.com/watch?v=jLvMGnAYicY",
+        "type": "video"
+      }
+    ]
+  },
+  "GoYEAU_lZ186M3IJY48O6": {
+    "title": "Introduction",
+    "description": "The introduction phase of the product development lifecycle marks the transition from development to market entry, where the product is launched and made available to customers. For product managers, this phase involves executing go-to-market strategies, coordinating marketing and sales efforts, and closely monitoring the product's performance in the market. This period is critical for building brand awareness, attracting early adopters, and gathering initial customer feedback. Effective management during the introduction phase ensures a smooth launch, helps identify and resolve any post-launch issues, and sets the foundation for the product's growth and long-term success.",
+    "links": []
+  },
+  "ke5vl9p3ouupjVmgU5IKw": {
+    "title": "Growth",
+    "description": "The growth phase of the product development lifecycle follows the development and introduction stages, characterized by a significant increase in market acceptance and sales. For product managers, this phase involves scaling operations, optimizing marketing strategies, and enhancing the product based on customer feedback. The focus shifts to expanding market share, improving product features, and exploring new distribution channels. Effective management during the growth phase is essential for sustaining momentum, addressing competitive pressures, and maximizing profitability, ultimately securing the product's position in the market.",
+    "links": []
+  },
+  "aUJTPvO9Eb1UOD0MIY4Mf": {
+    "title": "Maturity",
+    "description": "The maturity phase of the product development lifecycle follows the development, introduction, and growth stages, representing a period where the product has achieved widespread market acceptance and stabilized sales. For product managers, this phase focuses on maintaining market share, optimizing operational efficiency, and extending the product's lifecycle through enhancements and diversification. Strategies during this phase include cost management, refining marketing efforts to retain loyal customers, and exploring opportunities for incremental innovation. Effective management during the maturity phase is crucial for sustaining profitability, fending off competition, and preparing for eventual market saturation or product evolution.",
+    "links": []
+  },
+  "yOve7g_05UMpXHcGpdZcW": {
+    "title": "Decline",
+    "description": "The decline phase of the product development lifecycle comes after the development, introduction, growth, and maturity stages, characterized by decreasing sales and market relevance. For product managers, this phase involves making strategic decisions regarding the product's future, such as discontinuation, repositioning, or reinvention. The focus shifts to cost reduction, managing inventory, and maximizing any remaining value from the product. Effective management during the decline phase is essential for mitigating losses, reallocating resources to more promising products, and planning for a smooth exit or transition, ensuring minimal disruption to the overall product portfolio.",
+    "links": []
+  },
+  "beca7sTxYY06RwNn5jpZM": {
+    "title": "Mind Mapping",
+    "description": "Mind Mapping is an essential tool in the arsenal of a Product Manager. It involves the graphical or pictorial representation of ideas or tasks emerging from a core central concept. As product managers wrestle with strategy formulation, project management, feature breakout, and stakeholder communication, mind maps provide a valuable ally to visualize complex concepts and relationships. Mind mapping encourages brainstorming, fosters association of ideas, and aids in effectively organizing and structuring the numerous elements of a product's lifeline.",
+    "links": []
+  },
+  "0emyqhl028_M6tdilfFC3": {
+    "title": "Brainwriting",
+    "description": "Brainwriting is a critical tool in the arsenal of modern Product Managers. It refers to a structured brainstorming technique where team members independently write down their ideas, then pass them on to others for the development and enhancement. In the realm of product management, this can help stimulate creative problem-solving and innovation, paving the way for new features, strategies, and improvements. It's a game-changer as it values the voices of all team members, reduces group pressure, and mitigates the problem of idea domination often present in traditional brainstorming sessions.",
+    "links": []
+  },
+  "uLSPKcypF06AhzoeNVtDk": {
+    "title": "SCAMPER",
+    "description": "SCAMPER is a powerful and dynamic brainstorming tool widely recognized in the area of Product Management. As a mnemonic acronym, it represents seven techniques to assist Product Managers: Substitute, Combine, Adapt, Modify/Magnify, Put to other uses, Eliminate and Reverse. It provides a structured method to challenge the status quo, encourage divergent thinking, and generate innovative product ideas. SCAMPER serves as a strategic tool, enabling Product Managers to analyze their current product portfolio, identify improvement areas, conceive new product features or entirely new products, ensuring competitive advantage and long-term business success.",
+    "links": []
+  },
+  "69IgqluiW9cVfezSIKInD": {
+    "title": "Brainstorming Techniques",
+    "description": "When it comes to the role of a Product Manager, brainstorming techniques are paramount, especially during the stage of Product Identification. This initial stage involves the generation and rallying of innovative ideas that could potentially translate into a viable product. The Product Manager is required to leverage different techniques, like mind maps, SWOT analysis, SCAMPER, or Six Thinking Hats, to effectively encourage creativity, drive cross-functional collaboration, and foster a breeding ground for market-leading product concepts. Effective brainstorming sessions can reveal unique market opportunities, create an alignment of vision among teams, and contribute to the overall product strategy.",
+    "links": []
+  },
+  "vP4tfzP-hOiAsv4K4RsQy": {
+    "title": "Discovery",
+    "description": "The discovery phase is a crucial stage in a Product Manager's role. It involves exploring, researching, understanding customer needs, and identifying market opportunities to develop a product that aligns with business goals while providing value to users. During this phase, Product Managers gather and analyze data from customers, competitors, and the market to clearly define the problem to be solved. Visual forms like customer journey maps, personas, or prototypes are often used to effectively communicate the findings. The insights gained during the discovery phase set the foundation for the decisions made in the subsequent product development phases.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "Introduction to Modern Product Discovery by Teresa Torres",
+        "url": "https://youtu.be/l7-5x0ra2tc?si=Zh4LeSF_qAj8y6-a",
+        "type": "video"
+      }
+    ]
+  },
+  "toc34xxsB_tnHtekk1UmN": {
+    "title": "Selection",
+    "description": "The Selection process in Product Management involves identifying which features and projects to prioritize, based on the product's strategic direction, business objectives, customer needs, and market trends. As a Product Manager, understanding how to effectively carry out this selection process is critical in managing resources efficiently, aligning team efforts towards high-impact tasks, and driving product success in the market. This process usually involves tools and frameworks, such as product roadmaps, prioritization matrices, user feedback, and data analysis.",
+    "links": []
+  },
+  "fK3ZaX7Amna1oa_T5axVk": {
+    "title": "Validation",
+    "description": "Validation in the context of Product Management, refers to the process of ensuring that a product, feature, or concept meets the needs and expectations of the targeted end-user population. Product Managers carry out this process before the development phase to mitigate risks and avoid potentially costly mistakes. Validation helps in identifying if the problem is worth solving, gauges market demand, and validates the proposed solution. Typically, this might involve user interviews, surveys, prototypes, and market research. It plays a crucial role in decreasing uncertainties and refining the product roadmap. Its objective is to build a product that provides sufficient value to customers and meets business goals.",
+    "links": []
+  },
+  "1HytzY1KRYIQWoQa5FMwY": {
+    "title": "Iterative Process",
+    "description": "The Iterative Process is a fundamental approach in product management, which allows Product Managers to continuously improve and refine their products. In essence, it means creating, testing, refining, and repeating. Using this methodology, a Product Manager incrementally enhances the product based on feedback and learnings from each iteration. This constant evolution of the product makes for a more flexible development process, particularly useful in dynamic environments where user needs or market conditions may frequently change. Understanding and applying the Iterative Process can greatly enhance the ability of a Product Manager to deliver an effective and successful product to the market.",
+    "links": []
+  },
+  "LhNgyNDeqCAD--dAzf6u8": {
+    "title": "Execution",
+    "description": "Execution in the context of a Product Manager refers to the practical implementation of strategic plans. A Product Manager not only has to devise innovative solutions and streamline their visions but also successfully execute those plans. This involves managing resources, mitigating risks, working in collaboration with different teams, and ensuring the product development aligns with the customers’ needs and the company’s objectives. Sound execution skills are vital for a Product Manager as they directly impact the success or failure of a product in the market.",
+    "links": []
+  },
+  "gjdCSm_jZmG_q6YjG_8Qu": {
+    "title": "Blue Ocean Strategy",
+    "description": "Blue Ocean Strategy is a significant methodology in product identification for a Product Manager. It's a marketing theory from a book published in 2005 which advocates the creation of new demand in uncontested market spaces, or \"Blue Oceans\". Rather than competing within the confines of the existing industry or trying to steal customers from rivals (Red Ocean Strategy), Blue Ocean Strategy proposes to create a new space in the market, thereby making the competition irrelevant.\n\nFrom a product management perspective, this involves implementing innovative ideas, seeking new opportunities and envisioning potential markets. Product Managers, hence, are able to utilize this strategy to develop unique products that can trigger exponential growth and success for their organizations. In a nutshell, Blue Ocean Strategy provides a creative and systematic approach towards successful product identification and differentiation.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "How To Differentiate Your Business With BLUE OCEAN STRATEGY",
+        "url": "https://www.youtube.com/watch?v=UKDxj6W7CXs",
+        "type": "video"
+      }
+    ]
+  },
+  "DEwte-c-jxAFpiaBXAPSO": {
+    "title": "TRIZ (Theory of Inventive Problem Solving)",
+    "description": "TRIZ is a problem-solving, analysis and forecasting tool derived from the study of patterns of invention in the global patent literature. In the realm of product management, TRIZ aids Product Managers to ideate innovative solutions, accelerate product development, solve complex problems and predict future technology trends. Understanding and applying TRIZ principles can empower Product Managers to overcome cognitive biases, break away from traditional patterns of thinking, and improve ideation and product innovation by providing systematic approaches and methodologies.",
+    "links": []
+  },
+  "aBJUQvgXmvpLPOhpDTn7l": {
+    "title": "Problem Framing",
+    "description": "Problem Framing is a vigorous process undertaken by Product Managers to clearly understand, articulate, and define the issues that a product or service aims to resolve. It necessitates critical and creative thinking to identify the root cause of a problem, its potential implications, its users, and the impact of its solutions. Essentially, a well-framed problem can guide Product Managers while they navigate through the product's design and development phases, ensuring that the final product successfully addresses the issue at hand and delivers substantial value to its users.",
+    "links": []
+  },
+  "fmpJB_14CYn7PVuoGZdoz": {
+    "title": "Product Identification",
+    "description": "Product Identification plays a critical role in the diverse spectrum of responsibilities held by a Product Manager. It typically involves identifying and detailing the core features, value proposition, and user demographics of a product. This is an essential preliminary step in product development that not only assists in recognising the unique selling points but also helps in positioning the product appropriately in the competitive market. The rationale, advantages and potential of a product are all captured during the product identification process, making it a key strategic roadmap element for a Product Manager. Knowledge of product identification can empower Product Managers to make informed decisions that align with user needs and business goals.",
+    "links": []
+  },
+  "Eusp5p6gNIxtU_yVvOkmu": {
+    "title": "Market Analysis",
+    "description": "As a central aspect of a Product Manager's role, market analysis encompasses the examination of the market within which the product will operate. It includes a detailed understanding of potential consumers, competitors, and market conditions. Market analysis helps Product Managers to develop strategic plans, set objectives, and make informed decisions about product development, positioning, and growth strategies. This extensive research forms the groundwork for understanding market trends, industry patterns, customer behavior and the competitive landscape.",
+    "links": []
+  },
+  "8LAy6uBfrdtrjF8ygAGoo": {
+    "title": "User Research",
+    "description": "User research is a critical aspect of a Product Manager's role. It is through understanding the needs, behaviors, and pain points of a user that a Product Manager can create, refine, and market products successfully. User research is not a one-time event but a continuous process that helps Product Managers stay abreast of their target market's evolving demands and expectations. Methods used include interviews, surveys, usability testing, and observation, among others. By staying connected to the users' perspectives, a Product Manager can ensure a more user-centric product development process resulting in a product that genuinely meets and exceed user expectations.",
+    "links": []
+  },
+  "YPqdrZguH0ArEFSe-VwKS": {
+    "title": "Positioning",
+    "description": "Positioning, within the realm of product management, refers to the delicate art of crafting and communicating a product's unique value proposition to the intended audience, in relation to competing products. It's about defining where your product fits into the market and how it should be perceived by its consumer base. A seasoned Product Manager meticulously shapes and controls this perception in order to strengthen the product’s standing in the market, increase sales, and boost the overall brand image. The correct positioning strategy can ultimately lead to a product's success or failure. For Product Managers, mastering this strategic function is a key element in directing both product development and marketing efforts.",
+    "links": []
+  },
+  "LkDLk6DsEvbFXZPGOhD0C": {
+    "title": "Identifying Market Needs",
+    "description": "Identifying market needs is a fundamental task for a Product Manager during the process of market analysis. A market need is what motivates a consumer to buy a product or service. The market analysis mandates the Product Manager to study the market, understand the customers' behavior patterns and preferences, and keep an eye on current market trends. This data-driven outlook helps the Product Manager decipher the gaps in the market, what pain-points the potential customers have that are unresolved, and hence, find opportunities to create new products or enhance existing ones. Glazing through customer feedback, surveys, and competitor analysis are some of the methods that help identify these needs and provide the launchpad for successful product planning and development.",
+    "links": []
+  },
+  "PBDlYIyS8LAyPE6tV-kU7": {
+    "title": "Competitive Analysis",
+    "description": "Understanding the competitive landscape is a critical aspect of a Product Manager's role. Competitive analysis involves identifying your competitors and evaluating their strategies to determine their strengths and weaknesses relative to your own product or service. A product manager uses competitive analysis to understand market trends, discover opportunities for growth, and determine competitive advantages. It is an essential factor in positioning, marketing, and strategic decision-making. This process of understanding often involves collecting and reviewing information about competitor products, including their features, functionality, pricing structures, and success within target markets.",
+    "links": []
+  },
+  "aDhSpLRZ6Sd8SnkcwtyLf": {
+    "title": "Emerging Market Trends",
+    "description": "Understanding emerging market trends is a critical aspect of a Product Manager's role. Market analysis involves closely observing changes, patterns, and shifts in the marketplace to not only anticipate customer needs and preferences but also efficiently strategize the product's design, development, and positioning accordingly. Keeping track of emerging market trends provides a competitive edge, aids in identifying opportunities for innovation, and enables better decision-making to ensure product success and sustainability in the market.",
+    "links": []
+  },
+  "0y8F9x6MhApQkS1VhS8Dx": {
+    "title": "User Personas",
+    "description": "User Personas are considered foundational in user research in product management. These are fictional characters or profiles representing a certain user segment for a product or service. For a Product Manager, understanding user personas is crucial as it allows them to better identify with the user's needs, behavior patterns, and goals. It serves as a tool that humanizes these users and allows for a more personalized approach when designing a product or service. They contribute towards making informed decisions about product features, user interface, and overall user experience. Thus, user personas play a significant role in aligning all stakeholders in a product lifecycle on who the target users are.",
+    "links": []
+  },
+  "5kt8AkCsdAdlBmsKOkKFH": {
+    "title": "User Interviews",
+    "description": "For a Product Manager, User Interviews are a key instrument in User Research. They provide a pristine opportunity to understand the user's needs, problems, motivations, and behaviors. This process involves having a one-on-one conversation with current or potential users of a product to understand their experiences with the product, to gain insights about their needs and wants, and to determine how a product can be improved to meet the user's expectations. If conducted effectively, user interviews can help a Product Manager to make informed product development decisions thereby increasing user satisfaction and product success.",
+    "links": []
+  },
+  "a_5AyOKAgcg0rArZfapA_": {
+    "title": "Surveys and Questionnaires",
+    "description": "For a product manager, understanding the needs, wants, and experiences of users is a critical task. This comprehension is often facilitated through user research, where tools like surveys and questionnaires come into the picture. These tools enable product managers to garner valuable insights about user behavior, preferences, and pain points. With well-crafted surveys and questionnaires, product managers can proactively address user needs, refine product strategy, and ultimately create products that provide high value and usability.",
+    "links": []
+  },
+  "VwI7plziVzwkp3KZd4466": {
+    "title": "Ethnographic Research",
+    "description": "Ethnographic research, stemming from anthropology, is a significant methodology often adopted by product managers to gain a profound understanding of user behaviours, routines, cultures, and motivations in their natural surroundings. It is essential as it offers contextual and holistic insights on user behaviour that other methods, like surveys or interviews, may not provide. For a product manager, this research helps compose a more empathetic and comprehensive user point-of-view, thus successfully driving product decisions that meet users' needs more effectively. This may involve observing users interact with the product in their everyday life, carrying out contextual inquiry, or even studying competitors to understand the factors that drive users towards specific actions. Understanding the subtleties of user behaviour through ethnographic research can truly create the difference between a good product and a great one.",
+    "links": []
+  },
+  "tKDlfVvNym_OIqkommiJ8": {
+    "title": "USP (Unique Selling Point)",
+    "description": "In the competitive realm of product management, a Unique Selling Point (USP) can be considered as the DNA of your product. It is that distinctive edge or feature that positions your product uniquely in the market and makes it stand out from the crowd. For a Product Manager, comprehending the USP of their product is vital, as it not only aids in driving the product strategy and development but also impacts the marketing campaigns and sales propositions. It gives direction to both the inward and outward-facing decisions and actions pertaining to the product. This nucleus feature, in essence, becomes a crucial factor in setting up the product's market positioning. Hence, a sound grasp of the USP can act as a guiding compass in the successful management and evolution of a product.",
+    "links": []
+  },
+  "3MYjrnd6h2ZlcfaXjUbkC": {
+    "title": "Market Segmentation",
+    "description": "As a Product Manager, understanding market segmentation is crucial in the process of positioning your product. Market segmentation involves dividing a market into distinct groups of buyers who have different needs, characteristics, and behaviors, and who might require separate products or marketing mixes. It helps product managers identify and analyze potential customers, their needs, and how the product can meet their needs. Furthermore, using market segmentation for positioning assists in developing a product's unique selling proposition, thus facilitating a stronger connection with targeted customer segments. Without proper market segmentation, product positioning may become less effective and could result in wasted marketing efforts.",
+    "links": []
+  },
+  "JhhjMPTNb646aQKlS_cji": {
+    "title": "Case Studies",
+    "description": "Case studies play a pivotal role in exhibiting the efficiency of a product and its potential value in the lives of customers. For Product Managers, understanding case studies in positioning is invaluable. It allows them to comprehend how a product fits into a market, how it behaves in relation to competitors, and how it meets customer needs. These case studies provide insights into the real-world application and results of strategic positioning, enabling Product Managers to devise more effective strategies that attract target customers and build lasting brand value.",
+    "links": []
+  },
+  "l-KrmCOKEfpLHq4j-9SoY": {
+    "title": "Vision & Mission",
+    "description": "A critical aspect of a Product Manager's role is to understand, define and communicate the Vision and Mission of their product. The Vision is the long-term goal, reflecting what the product aims to achieve or become in the future. This provides a strategic direction that aligns all stakeholders. The Mission, on the other hand, is a tactical plan detailing how the product will achieve this Vision. It involves specific, actionable objectives that can be assessed and adjusted periodically. Together, the Vision and Mission guide the Product Manager in making decisions, prioritizing actions and inspiring the team.",
+    "links": []
+  },
+  "DnKHDm0TZ7QQUyrhPdqkV": {
+    "title": "Statement",
+    "description": "As a Product Manager, an integral part of your responsibility revolves around defining and understanding the Vision and Mission statement of the product you are managing. These statements not only align the team and the organization with a specific goal, but they also provide a roadmap of the larger purpose that the product aims to serve in the most succinct way possible. A clear and motivating Vision and Mission statement can lead to empowered teams and efficient decision-making processes. The Vision depicts the ultimate goal of the product, where it aspires to be. The Mission, on the other hand, focuses on the present, defining the purpose of the product, the why and the how behind its existence. Gaining a deep understanding of these statements becomes an essential aspect of successful product management.",
+    "links": []
+  },
+  "ZCTSbMHAMSaOxlqaJImzr": {
+    "title": "Proposition",
+    "description": "As a critical cog in the wheel, a Product Manager is closely entwined with the strategic development of the product's proposition under the company's vision and mission. This involves understanding and aligning the product's value proposition with the overarching business objectives. A well-articulated proposition gives direction to the product development process, influences the marketing strategies, and contributes to creating a product that rings true to the brand promise. The role of the Product Manager here is multifaceted—they contribute to defining, refining, and maintaining this proposition while ensuring it's in sync with the customers' needs and market trends. They also act as a crucial link between various stakeholders, including leadership, technical teams, and customers.",
+    "links": []
+  },
+  "8srsCEv55zh1y4gsp-rCO": {
+    "title": "Capabilities",
+    "description": "The role of a Product Manager is multifaceted and one important aspect of that role revolves around setting and understanding the vision and mission. A vision is a long-term goal or aspiration for a product and encompasses the overall direction or strategy for the product. Conversely, a mission statement focuses more on the present, describing the purpose of the product and who it serves. These aspects help drive the decision-making process in product management. Product Managers utilize these tools to align the product team and the company as a whole. They make strategic decisions and formulate plans based on the foundation set by the vision and mission. By leveraging these capabilities, Product Managers are able to make informed decisions that propel the product towards success.",
+    "links": []
+  },
+  "eKJ2XfDxu0NAKA932tbzy": {
+    "title": "Solved Constraints",
+    "description": "The role of a Product Manager extends to managing and solving constraints regarding a product's vision & mission. The mission is the purpose that propels the product towards its ultimate goal, while the vision outlines where the organization or product aims to be in the future. The complexities lie in the constraints that might hinder the product's way to achieve its vision and mission. These constraints could be technical, financial, time-bound, resource-based, and more. The Product Manager's responsibility is to identify these constraints, design strategies to overcome them, and effectively implement those strategies, thereby channeling energy in alignment with the product's mission and vision.",
+    "links": []
+  },
+  "wuqZntn1ivkr9AV_09zYX": {
+    "title": "Future Constraints",
+    "description": "As a product manager, one has to deal with various constraints while building a product strategy which aligns with the company's vision and mission. Future Constraints under Vision & Mission dives into these upcoming limitations or challenges that may impede the pursuit of the organization’s goals. These could range from technical or resource limitations, to market changes, regulatory environments and competitive forces. To successfully design and deliver products, understanding these future constraints is vital for a Product Manager. This allows them to proactively plan and devise effective strategies to tackle potential issues, ensuring the product direction remains aligned with the organization's vision and mission.",
+    "links": []
+  },
+  "uXseNTJlteD6Fgi1bzQB4": {
+    "title": "Reference Materials",
+    "description": "When considering the role of a Product Manager, one must appreciate the crucial impact of \"Reference Materials under Vision & Mission\". These materials comprise everything from project proposals and business plans to company strategy documents and competitors' analysis reports. They serve as a factual and thematic basis for a product manager's day-to-day decisions and long-term strategic planning. Understanding the company’s vision and mission is a foundational requirement for a product manager since they act as a guiding compass for all product development activities, ensuring alignment of all efforts towards achieving the company's goals.",
+    "links": []
+  },
+  "zS_CjYSTOIkJZn-oUEvgh": {
+    "title": "Narrative",
+    "description": "A Product Manager, in their role, often stands as the conduit linking different business components, including customers, sales, marketing, and engineering. A crucial aspect of this role involves crafting the narrative under the Vision & Mission of their product. This narrative is a strategically designed story that brings to life, the product's purpose, its potential market impact, and the roadmap to its success. The narrative not only sets the direction for the team but it also helps stakeholders understand the product’s strategic importance. From illustrating the product's value proposition to external audiences to aligning internal teams, a solid, compelling narrative, shaped by the Product Manager, is crucial in defining and driving a product’s vision and mission.",
+    "links": []
+  },
+  "n2AYdM2dlJfuZ97jXY49U": {
+    "title": "Defining Goals",
+    "description": "As a Product Manager, defining goals is a critical aspect of your role. Having clear, well-defined goals crafting the strategic roadmap for your product. This involves identifying the desired outcomes or changes that need to be achieved within a specified timeline. These encompass various facets including market share, revenue, user experience and product functionality among others. Setting these goals requires a combination of data-driven insights, understanding of market trends and user feedback. Ultimately, these goals will serve as the guiding points for the development teams and stakeholders, streamlining efforts towards the shared vision. Your ability to articulate these goals effectively, will directly influence the success of the product.",
+    "links": []
+  },
+  "tmlFCmEuYpcUnt8VvVP9R": {
+    "title": "Target",
+    "description": "These goals specify a clear and quantifiable objective that the product aims to achieve, such as increasing user engagement by 20% within six months.",
+    "links": []
+  },
+  "GPRqshiha8Pi4a4ImW8-5": {
+    "title": "Baseline",
+    "description": "These goals aim to maintain or improve the current level of performance, such as keeping customer satisfaction scores above a certain threshold.",
+    "links": []
+  },
+  "s8mK1llA32B69_rzOwcwN": {
+    "title": "Trend",
+    "description": "These goals focus on leveraging or reversing observed trends, such as accelerating a growing user adoption rate or halting a declining market share.",
+    "links": []
+  },
+  "E1yPzEhssJWMDLeSiL4cj": {
+    "title": "Timeframe",
+    "description": "These goals set a deadline for achieving specific outcomes, such as launching a new feature by the end of Q3 or completing a market analysis within two weeks.",
+    "links": []
+  },
+  "6OjKcLbUZVJdUDC7if0Uy": {
+    "title": "Value Proposition",
+    "description": "As a product manager, understanding, defining, and communicating your product's value proposition is vital. It refers to the unique value that a product or service provides to a customer, highlighting the reasons why they should choose your product over competitors. It's a differentiator that sets your product apart and communicates the additional benefits that customers would receive. A compelling value proposition aligns with customer needs and demands, positions your product fittingly in the market, and serves as a foundation for the product strategy and roadmap.",
+    "links": []
+  },
+  "1j2ZSo7UGnBgoLpYzsA5t": {
+    "title": "Defining Value Proposition",
+    "description": "The Value Proposition serves as the foundation for a product manager's strategy, directly influencing the design, development, and marketing decisions of a product. By defining the unique value your product brings to the market, you communicate its benefits, solve customers' problems, and outdo competitors. A well-articulated value proposition is crucial as it affects every aspect of your product—from conception to final sale. For a product manager, understanding and continually refining the value proposition can guide decision making, target key demographics more effectively, and increase overall user satisfaction.",
+    "links": []
+  },
+  "kjKUrKdtCM95VinlluKDS": {
+    "title": "Value Proposition Canvas",
+    "description": "The Value Proposition Canvas is an essential tool for Product Managers. It aids in understanding deeply about customer needs and ensuring that the product delivers on those. Essentially, it helps in aligning the product’s features with the customer's requirements and expectations. This powerful strategic management tool is used to comprehend customer segments, their challenges, and how the product can solve those. With its ability to identify the product-customer fit, it significantly reduces the risk associated with product failure and aids in the successful rollout of products.",
+    "links": []
+  },
+  "0AQj2F1n8VKHBwuF4ywrp": {
+    "title": "Value vs Features",
+    "description": "In the realm of product management, a key decision-making factor is striking a balance between value and features. Product managers are often caught in the dilemma of whether to focus more on increasing the number of features, making the product functionally rich, or to focus on the core value that a product would deliver to the user. While features may seem appealing and can act as selling points, it's the genuine value or solution to the customer's problem that tends to encourage satisfaction and loyalty. To make this complex decision, Product Managers often use strategies such as customer feedback, market research, competitor analysis, and various prioritization frameworks.",
+    "links": []
+  },
+  "xu8A_QKs6lXzKPMiifNF_": {
+    "title": "Finding Balance",
+    "description": "As a Product Manager, one vital skill required of you is understanding the balance between value and features. This revolves around prioritizing what features to implement based on the value they provide to the customer or user. It is about striking a balance; not all features will provide the same level of value, and understanding this is key to efficient resource allocation. You must maintain a focus on delivering value while also ensuring the product's features remain compelling and relevant to the target audience.",
+    "links": []
+  },
+  "GbFbURxIRD76kyR9vKfdg": {
+    "title": "Feature Creep",
+    "description": "Feature creep, also known as requirements creep or scope creep, is a term commonly used by product managers. It refers to the continuous expansion or accumulation of features in a product, that goes beyond its original scope and requirements. This can lead to project bloat and veer off the product from its intended course and business objectives. Despite the temptation to add more features to satisfy varied user requirements, a good product manager should keep a balance and manage feature creep effectively. The aim is not only to deliver a product that meets the users' needs, but also stays on schedule, within budget and aligned with the product vision.",
+    "links": []
+  },
+  "m46lX4dUHik_BSHQwaU2l": {
+    "title": "Strategic Thinking",
+    "description": "Strategic thinking is a critical competence for Product Managers. This involves the ability to think long-term, beyond immediate actions, to comprehend how various components influence each other within the big picture, as well as predicting potential outcomes. It's about identifying strengths and weaknesses, understanding opportunities and threats, planning for diverse scenarios, and making sound decisions. A Product Manager with strategic thinking skills effectively aligns product decisions with the broader organizational strategy, anticipates upcoming market trends, and maintains a competitive edge.",
+    "links": []
+  },
+  "qy_IXzenBOEVBMvVlXPaY": {
+    "title": "Competitive Strategy",
+    "description": "Product Managers play a crucial role in defining and implementing the competitive strategy of a product. This strategy is typically a long-term action plan for a company that identifies how to achieve a competitive advantage while meeting the needs of its customers. Product managers, with their deep understanding of the market, identify opportunities, understand competitors, and align the product to meet business goals and customers' needs. Strong strategic thinking aids in making informed decisions towards competitive positioning of the product, considering factors such as pricing, features, and marketing strategies.",
+    "links": []
+  },
+  "8CW_clQsc6SC4piQ3__0I": {
+    "title": "Five Forces Analysis",
+    "description": "Five Forces Analysis, developed by Michael E. Porter, is a critical tool that a Product Manager can utilize to understand the competitive forces within the industry and help inform product development strategy. This analysis includes five different forces: potential new entrants, substitute products or services, bargaining power of buyers, bargaining power of suppliers and competitive rivalry. By thoroughly examining these areas, a Product Manager can uncover opportunities, mitigate challenges, and position the product to achieve sustainable profitability. It also supports crucial decisions around pricing, marketing, and development prioritization. Thus, mastering Five Forces Analysis is fundamental for successful product management.",
+    "links": []
+  },
+  "tTUp4GQHvjLZYkySasQFE": {
+    "title": "Competetive Advantage",
+    "description": "Competitive advantage stands at the core of a product manager's role and responsibilities. A competitive advantage ensures that a product or service has unique attributes that set it apart from rival offerings, providing a strategic advantage in the market. A product manager must understand and leverage this unique value proposition to attract, retain, and potentially expand the customer base. Thus, competitive advantage is essential for creating strategies, defining the roadmap, making crucial product decisions, and driving growth.",
+    "links": []
+  },
+  "jWU_odHoQYk3GKCPoRV2n": {
+    "title": "Strategic Partners",
+    "description": "In the role of a Product Manager, a crucial aspect is managing and guiding strategic partners. Strategic partners are organizations or individuals that a company forms alliance with to mutually develop, promote, and distribute products or services. For a product manager, this involves understanding the capabilities of potential partners, determining how to leverage their strengths for the product's growth, as well as maintaining a positive and productive relationship with them throughout the product lifecycle. This could range from sourcing raw materials to providing distribution network or even technological support, depending on the nature of the product. In brief, strategic partners significantly contribute in shaping the product's roadmap, influencing its performance in the market, and advancing overall business objectives.",
+    "links": []
+  },
+  "1M6WpW1wbJcXMb3nf10U2": {
+    "title": "Identify Partners",
+    "description": "Identifying partners is a critical element in the role of a Product Manager. This refers to the process of discovering and aligning with other individuals, teams, or organizations that can assist in boosting the product's value proposition. This is achieved either by improving its features, outreach, access to resources, or customer adaptations. A strategic alliance can streamline the process of product development and provide access to niche markets and specialized technologies. Solid partnerships can amplify the potential of the product, save resources and time, and provide a competitive advantage in a saturated market landscape.",
+    "links": []
+  },
+  "vXnf1AcMidLww5EypChWk": {
+    "title": "Managing Partnerships",
+    "description": "Product Managers often work at the intersection of business, technology, and user experience. An integral part of their role includes managing partnerships. This involves identifying and fostering strategic partnerships that can aid the company in achieving its business goals, optimizing product performance, and enhancing market reach. Relationships can range from technology partners, distribution affiliates, to marketing collaborators. Effective partnership management needs insightful planning, excellent communication and strong negotiation skills. It provides a powerful platform for increasing competitive advantage, gaining access to essential resources and expanding customer base.",
+    "links": []
+  },
+  "0tJ7zlgOIaioCMmVavfqz": {
+    "title": "Product Requirements",
+    "description": "Product requirements are a vital component in the realm of product management. They represent the critical elements, features, and functionalities that a product must possess to meet the needs and expectations of customers, stakeholders, and the business itself. Product Managers hold the responsibility to define, document, and communicate these requirements effectively with all parties involved. This process involves understanding customer needs, market trends, and technical feasibility, translating these understandings into well-defined requirements for the development teams. Thus, mastering the art of product requirements is an essential skill for a successful Product Manager.",
+    "links": []
+  },
+  "0FqpBfvnkGN_oE2KSC-_8": {
+    "title": "Writing PRDs",
+    "description": "In the realm of product management, writing Product Requirement Documents (PRDs) serves as a crucial part of the job. This activity involves detailing and articulating the product’s purposes, features, and functionalities. PRDs become a roadmap that guides the design and development team. As a Product Manager, you play a pivotal role in crafting a well-structured PRD, ensuring it clearly communicates the product's vision to stakeholders and enables seamless product development.",
+    "links": []
+  },
+  "kN-UfAbQ8j7g0jDdqWK55": {
+    "title": "User Stories",
+    "description": "For a product manager, understanding user stories is an essential part of defining product requirements. A user story is a tool used in Agile development that captures a description of a product feature from an end-user perspective. User Stories helps the product manager not only in understanding and noting down the user's perspective but also in communicating this perspective to the design and development teams efficiently. User stories depict the type of user, what they want, and why, giving the team a clear focus of what needs to be accomplished. Therefore, as a product manager, utilizing user stories can lead to products that meet user expectations and demands effectively.",
+    "links": []
+  },
+  "B9fgJmzVViaq7dvSuEglb": {
+    "title": "Job Stories",
+    "description": "The concept of Job Stories is a tool integral to a Product Manager's dynamic role. Structured differently from traditional user stories, Job Stories shift the focus from personas to the situation, providing a fresh perspective for understanding user requirements. They provide an opportunity for product managers to emphasize the context and causality of user needs. This perspective plays a crucial role in creating successful products and ensuring they deliver value to the end-users. Teleriking why and when someone uses the product opens avenues for actionable insights leading to judicious decision-making in defining product requirements.",
+    "links": []
+  },
+  "gS3ofDrqDRKbecIskIyGi": {
+    "title": "Product Roadmap",
+    "description": "The product roadmap is a strategic document that provides a detailed overview of the product's direction and vision. It outlines the product's plans, both tactical and strategic - including the specific steps necessary to achieve the company's goals and vision. As a Product Manager, you are expected to guide the creation of the product roadmap, communicating the product’s evolution to the team, stakeholders, and customers. This tool serves as an essential reference point helping to align all stakeholders with the key priorities and vision of the product, and acts as a guide for decisions around product development.",
+    "links": []
+  },
+  "eiqV86PWizZPWsyqoBU5k": {
+    "title": "Creating a Roadmap",
+    "description": "A product manager plays an essential role in setting a strategic direction for the products they are tasked with guiding. An integral part of this role is creating a product roadmap. This key document outlines the vision, direction, and progress of the product over time. It is a detailed plan that explains how the product is likely to grow, the strategy behind it, and the steps necessary to achieve its development goals. It is imperative for a product manager to create and maintain a product roadmap, as it provides a clear path for everyone involved and sets realistic expectations regarding the product's evolution. The roadmap keeps the product manager, the development team, stakeholders, and customers on the same page, allowing for seamless collaboration and effective decision-making.",
+    "links": []
+  },
+  "k7Zv7IS9y-jkI_zGrBQG3": {
+    "title": "Prioritising Features",
+    "description": "The role of a Product Manager often necessitates the task of prioritising features in a product’s development roadmap. This pivotal process involves identifying what features or enhancements will serve the product, business, and customers best, considering the balance of business viability, technical feasibility, and customer desirability. Numerous methodologies can be applied to feature prioritisation, including the MoSCoW method, RICE scoring, or the Kano model, each influencing the order of feature implementation. Perfecting this process can lead to improved resource allocation, better product releases, and maximized customer satisfaction.",
+    "links": []
+  },
+  "qGvHqOSTPyVKll4mMVk7i": {
+    "title": "Continuous Roadmapping",
+    "description": "In the dynamic world of product development, a Product Manager needs to utilize effective strategies to navigate the fluctuating market needs and demands. Continuous Roadmapping is an essential tool that allows for flexible and adaptable planning in line with these changes. Under this methodology, product managers continually adapt and update the product roadmap as new information, data, and feedback become available. This enables them to respond proactively to shifts in business goals, customer needs, and the market landscape, ensuring that the product remains relevant and competitive, while aligning its development with the brand's strategic objectives.",
+    "links": []
+  },
+  "1uAfy3ISLKGmLirvIfzfE": {
+    "title": "Outcome-Based Roadmaps",
+    "description": "Outcome-Based Roadmaps refers to the strategic planning approach of focusing on the desired results of an organization or project rather than the specific tasks or features to be completed. For a Product Manager, creating outcome-based roadmaps requires a top-down approach, putting the focus on solving problems and achieving objectives over defining strict specifications or tasks. This allows for more flexibility and innovation in product development and strategy. It also necessitates a deep understanding of customer needs, the ability to articulate clear goals and progression metrics, and the skill to collaborate with cross-functional teams to see those goals to fruition.",
+    "links": []
+  },
+  "NjLt_B_kV7FdnkOomqayx": {
+    "title": "Communicating the Roadmap",
+    "description": "An essential role of a Product Manager involves communicating the product roadmap. This strategic document delineates the vision, direction, priorities, and progress of a product over time. It is paramount that this roadmap is communicated effectively to various stakeholders including team members, leadership, clients, and investors. This not only sets appropriate expectations but also ensures that everyone associated with the product is on the same page. The successful alignment increases the chance of product success and reduces the scope of misunderstandings and delays. For a Product Manager, mastering this communication is key to leading a product effectively.",
+    "links": []
+  },
+  "lq5Hl1ZXBQRRI_4ywn7yA": {
+    "title": "Backlog Management",
+    "description": "Backlog Management is a critical aspect in the role of a Product Manager. It involves organizing and prioritizing a list of tasks or features - known as the \"backlog\" -that are required for the development of a product. Effective backlog management ensures that the product team is working on the most valuable features at the right time, thereby maximizing the product's value and reducing time to market. It requires continuous collaboration with stakeholders, balancing business needs with technical feasibility, and strategically planning to meet short and long term objectives.",
+    "links": []
+  },
+  "Slb0P_LVdl7-GzUqbO33c": {
+    "title": "Prioritization Techniques",
+    "description": "Prioritization Techniques are the key strategies implemented by product managers to determine where to allocate resources and focus development efforts. These techniques help in identifying the most valuable and impactful features, products, and projects to undertake. Since time, budget, and resources are limited, it is crucial to prioritize works that align with the business objectives, customer needs, and market trends. These techniques can range from simple to sophisticated; including methods like the Eisenhower Matrix, RICE scoring, Weighted Shortest Job First (WSJF), and more. Mastering these techniques facilitates a product manager in making informed decisions and delivering maximum value to the customers and the business.",
+    "links": []
+  },
+  "sqxgqfxWMluhWtCWN8spG": {
+    "title": "Grooming Sessions",
+    "description": "In the realm of product management, grooming sessions are a crucial part of the Agile product development process. Also known as backlog refinement or story-time sessions, they help product managers, along with the development team, prioritise and refine the product backlog to ensure smooth execution of product delivery. During grooming sessions, product manager clarifies doubts about product backlog items, re-orders them based on business or technical priority and often breaks down large user stories into smaller, manageable tasks. They are integral in maintaining a well-organised, clear and up-to-date product roadmap.",
+    "links": []
+  },
+  "3JY85Tu40ABy9XfoliaqE": {
+    "title": "User Story Mapping",
+    "description": "User Story Mapping is a crucial practice product managers adopt under the broad area of backlog management. This strategic process encourages the development team and stakeholders to have a collaborated understanding of the product or application, as it aligns them into visualization and diagraming of user activities. User Story Mapping provides a structured approach to defining user interactions with the product, assisting Product Managers to prioritize requirements, and ultimately leading to a product that meets the needs of the users effectively. This approach allows the product manager to set realistic goals, enable seamless team collaboration, and ensure an efficient project schedule that captures the product's functionality from the user's perspective.",
+    "links": []
+  },
+  "-lFYy5W1YqWuTiM3QRF4k": {
+    "title": "UX / UI Design",
+    "description": "UX (User Experience) and UI (User Interface) design are integral parts of product management. A product manager often works closely with UX/UI designers to ensure that the product not only meets the functional requirements but also provides a seamless and engaging user experience. UX design focuses on the overall feel of the product, ensuring it solves problems for users effectively and provides a positive experience. On the other hand, UI design concentrates on the aesthetics of the product – its look and feel, responsiveness, and interactivity. Understanding UX/UI design is vital for a product manager as it heavily influences user satisfaction and product success.",
+    "links": []
+  },
+  "TwL-EqDorSgUpBYr4O4rf": {
+    "title": "Principles of UX Design",
+    "description": "When it comes to product development, one of the key roles a Product Manager must understand is the Principles of UX Design. UX (User Experience) Design is an intricate part of product management which aims at creating a streamlined and satisfying experience for the user interacting with a product. These principles guide designers and product managers alike in crafting products that aren't just functional but highly engaging. The skill of grasping these principles often separates successful products from the rest. A good understanding of UX Design principles helps product managers to maintain a user-focused approach throughout the product's life cycle, ensuring its viability in the market.",
+    "links": []
+  },
+  "zwrmh-djneZ8HIqbaBOkN": {
+    "title": "Wireframing and Prototyping",
+    "description": "Wireframing and prototyping form an essential part of product development, especially in the domain of UX / UI Design. For a Product Manager, understanding these processes serves as a crucial tool in enabling them to visualize the path of the user interface before it is fully developed.\n\nA wireframe is a basic, visual guide used to suggest the layout of fundamental elements in a web or mobile application. This serves as a skeleton for the structure of the app. The prototype, however, is a more comprehensive and interactive model of the product.\n\nBy integrating wireframing and prototyping within the design process, a Product Manager can test the product before the development phase, reduce unforeseen costs and changes, improve collaboration with stakeholders, and ultimately, ensure customer satisfaction.",
+    "links": []
+  },
+  "yPtxGBDEJkFBhF8ZgQUVH": {
+    "title": "Design Thinking",
+    "description": "As a Product Manager, understanding and utilizing Design Thinking in the context of UX / UI is a crucial aspect of the job. This innovative, solution-based approach to problem-solving allows Product Managers to create user-centered product designs that meet both user needs and business goals flawlessly. By incorporating Design Thinking, Product Managers can better empathize with the user, define the problem effectively, ideate creative solutions, prototype, and test the results, all contributing towards delivering a superior product. It's a process that emphasizes collaboration, user feedback, and iteration, thereby ensuring the product is continually refined and improved upon.",
+    "links": []
+  },
+  "lxU25qxxgxnNF3c3kdZxz": {
+    "title": "Service Design",
+    "description": "Service Design refers to the process of planning and organizing a business's resources (people, infrastructure, materials, etc.) to directly improve the service's quality, interactions between service provider and clients, and the customer's experience. For a Product Manager, it's a crucial practice as it gives them a broader understanding of their product's lifecycle and interactions with the end users. This process aids in crafting or refining products to ensure alignment with customer needs and provide superior user experience.",
+    "links": []
+  },
+  "S_-9msr3vGZgOQ36zErnf": {
+    "title": "Interaction Design",
+    "description": "Interaction Design is a key discipline within the field of Product Management. It focuses on the design and creation of digital interfaces and systems with which human users interact. As a product manager, mastery in interaction design is critical because the ease-of-use, intuitiveness, and satisfaction of a user's interaction with a product largely determine its success or failure. An Interaction-design-savvy product manager will strive to make sure the product offers a seamless user experience, ensuring it is aesthetically pleasing, easy to navigate, and delivers the desired functionality efficiently.",
+    "links": []
+  },
+  "v3hKowLMBVq9eCXkUhrDZ": {
+    "title": "User Testing",
+    "description": "User Testing is an essential responsibility for a product manager. In this process, the product manager ensures that the product developed by the team meets the users' needs and provides a good user experience. This is done by selecting representative users or personas, understanding the user's goals, implementing and planning test scenarios, facilitating the test and analysing the observed user behaviour. The feedback collected is then used to refine the product design, thus playing a significant part in shaping the product's road map and release cycle. Overall, User Testing provides invaluable insights that can often lead to significant improvements in the product.",
+    "links": []
+  },
+  "1uXjKKvOKqpO50m1pM627": {
+    "title": "Usability Testing",
+    "description": "Usability testing is a crucial aspect in a Product Manager's role. It essentially involves evaluating a product or feature by testing it with representative users. As a Product Manager, they must ensure that usability testing is performed at various stages of product development to understand and improve user satisfaction and experience. It provides direct input on how users use and perceive a product. Often, it is the Product Manager's responsibility to facilitate this process, from selecting suitable user groups to facilitating the sessions and analysing the results for future product iteration and improvement. Understanding usability testing allows Product Managers to identify any design problems and necessary improvements before full-scale product launch.",
+    "links": []
+  },
+  "Ws7IFrHQNoBjLE2Td2xIZ": {
+    "title": "A/B Testing",
+    "description": "A/B testing, otherwise known as split testing, is an essential statistical tool that is central to the responsibilities of a product manager. This method involves comparing two versions of a webpage, product feature, or user interface to determine which performs better according to certain metrics or goals. It allows product managers to make data-driven decisions and improve the product based on real user experiences and preferences. A solid understanding of A/B testing methods and application equips product managers with the ability to optimize user engagement, retention and conversion rates.",
+    "links": []
+  },
+  "5fze1aw1in3Gp3K31bvin": {
+    "title": "Remote User Testing",
+    "description": "Remote User Testing is a crucial aspect of the role of a Product Manager. This technique allows the validation of ideas, products, features, and updates with real users in their natural environment. This method of testing can provide invaluable insights into how users interact with a product, what challenges they might face, and what improvements can be made. For a Product Manager, implementing remote user testing into the development cycle can significantly aid in creating a user-centric product that meets the audience's needs and expectations. It is cost-effective, versatile, and applicable to a variery of stages in the product's lifecycle.",
+    "links": []
+  },
+  "sAu4Gr1hg8S4jAV0bOSdY": {
+    "title": "Agile Methodology",
+    "description": "Agile Methodology in product management refers to an iterative approach to project management and product development, where requirements and solutions evolve through collaboration among cross-functional teams. As a Product Manager, understanding Agile is essential since it not only speeds up the development process but also allows flexibility in response to changes. Agile can positively impact your product planning, product development, and customer feedback loop ensuring consistent improvement and value delivery.",
+    "links": []
+  },
+  "2r-NPGcROFmw-pd4rvsAJ": {
+    "title": "Working with Engineering Teams",
+    "description": "When it comes to the role of a Product Manager, effective collaboration with the engineering team is paramount. This involves fostering a strong communication culture, understanding technical constraints, and efficiently managing the product backlog. The relationship between a Product Manager and the engineering team can significantly influence the success of a product. Mutual respect, transparency and a clear understanding of roles and responsibilities help pave the way for a fruitful partnership.",
+    "links": []
+  },
+  "WNCVmFrpHW7rMaIzlLaXl": {
+    "title": "Scrum Basics",
+    "description": "The role of a Product Manager greatly correlates to the understanding and implementation of Scrum basics. Scrum is an agile framework that works towards delivering valuable products iteratively and incrementally. Scrum Basics cover a myriad range of concepts including, but not limited to, Scrum roles (Product Owner, Scrum Master, and the Development Team), Scrum artifacts (Product Backlog, Sprint Backlog, and Product Increment) and Scrum ceremonies (Sprint Planning, Daily Standup, Retrospective, etc.). An effective Product Manager is expected to thoroughly comprehend these components to smoothly manage projects, optimize product value and efficiently deal with complex situations, ensuring product success.",
+    "links": []
+  },
+  "kJ2HQFEsnc5yISU8d9Lla": {
+    "title": "Kanban Basics",
+    "description": "As a Product Manager in the fast-paced environment of technological innovation, being aware of and proficient in Agile methodology and specifically, the Kanban basics, is crucial. Originated in Toyota production system, Kanban is a visual tool that effectively supports the management of a product as it goes through its lifecycle. For a Product Manager, understanding Kanban basics implies being able to streamline workflow, limit work-in-progress and visualize work, thereby optimizing the efficiency of a team and the production timeline. Simply put, Kanban helps in managing work by balancing demands with available capacity, and improving the handling of system-level bottlenecks.",
+    "links": []
+  },
+  "bu-xm-L1XJgIPAFs2PieE": {
+    "title": "Sprint Planning",
+    "description": "In the role of a Product Manager, sprint planning is a fundamentally important aspect that dives into the management of product development in short 'sprints', or phases. It's a collaborative event in agile development where the team determines the product work that can be completed in the upcoming sprint. This essentially involves having the team understand the project's goals and scope from the Product Manager's perspective, direct stakeholders' input, and then translating these into concrete tasks for developers. Sprint Planning thus helps to ensure that everyone is on the same page and that development is effectively prioritized and focused.",
+    "links": []
+  },
+  "BzgGJbXIwQb0yR2ZMCmul": {
+    "title": "Daily Standups",
+    "description": "Daily standups, also known as daily scrum meetings, are a crucial part of a Product Manager's role in an Agile framework. They function as short, highly focused meetings where each team member summarizes their work since the last standup, their plan until the next one, and any obstacles encountered. For a Product Manager, participating and sometimes facilitating these meetings not only offers a clear view of the project's progress, but also helps in identifying and eliminating potential impediments for the team.",
+    "links": []
+  },
+  "AkKl7PrIPrIqXnss88v18": {
+    "title": "Retrospectives",
+    "description": "Retrospectives, also known as \"retros\", play an essential role in the life of a Product Manager. These are regular meetings where the team reflects on the past cycle of work, discussing what went well and where improvements should be made. For Product Managers, retrospectives provide an opportunity to assess the effectiveness of product strategies, to understand challenges faced during implementation, and to glean insights for future planning. These sessions are critical for continuous improvement, fostering a culture of transparency, and ensuring alignment across the team.",
+    "links": []
+  },
+  "mm5yvAaROsbwDgQUfnqyl": {
+    "title": "Minimum Viable Product (MVP)",
+    "description": "The Minimum Viable Product (MVP) is a crucial concept in the realm of product management. As a Product Manager, one is often tasked with defining and overseeing the development of the MVP. This refers to a version of a new product that allows a team to collect the most amount of validated learnings about customers with the least amount of effort. The principal advantage lies in understanding the interest and needs of the customers while saving time and resources. An effectively defined MVP can provide significant market insights, improve user experience in the final product, and increase likelihood for a successful product launch.",
+    "links": []
+  },
+  "53XS2zKdK6IDdOP07yiT7": {
+    "title": "Go-to-Market Strategy",
+    "description": "A Go-to-Market (GTM) strategy is an action plan that specifies how a product manager will reach target customers and achieve a competitive advantage. It serves as a blueprint that guides companies in introducing their products to the market. For a product manager, the GTM strategy is not just about product launch, it includes understanding the market dynamics, customer needs, creating marketing and sales strategies, and post-launch activities like customer service. An effective GTM strategy can help product managers ensure a successful product launch and strong market presence.",
+    "links": []
+  },
+  "PbhuFKsVNO6xGJHqXCwFl": {
+    "title": "Launch Planning",
+    "description": "The role of a Product Manager is central to launch planning. It involves designing and executing a strategic plan to introduce a new product or feature to the market. In order to ensure the success of the product, a Product Manager needs to collaborate with various departments such as design, development, sales, marketing, and customer service. They are responsible for setting the timeline, allocating resources, identifying target consumers, and setting price points. This requires a detailed understanding of the market, competitors, and the unique value proposed by their product. Launch planning is a critical phase in the product life cycle and its success greatly determines the trajectory of the product in the market.",
+    "links": []
+  },
+  "YYo_7lmTw7h74Y4J5pp-_": {
+    "title": "Marketing Strategies",
+    "description": "A Product Manager's job involves more than just overseeing the development of a product. They also play a crucial role in developing and implementing effective marketing strategies that align with the product’s goals and target market. This aspect involves understanding the market dynamics, competition, and user trends. Product Managers are responsible for translating these insights into strategies that drive the marketing campaigns, influence product positioning, branding, and promotion. It also includes measuring the success of every marketing initiative and tweaking plans as necessary to ensure the product’s success.",
+    "links": []
+  },
+  "wWWcIfPDGB92ed-1kV-uj": {
+    "title": "Growth Hacking",
+    "description": "Growth hacking is a pivotal concept that product managers must be familiar with in order to effectively strategize and achieve business growth. As a concept, growth hacking leverages data-driven and unconventional marketing strategies to help boost product growth. For a product manager role, understanding growth hacking means utilizing the principles to conceive effective marketing strategies that accelerate the product's market performance and user base. Market understanding, creativity, analytical thinking, and data insights are key elements of growth hacking a product manager needs to grasp.",
+    "links": []
+  },
+  "VqNK1rNAnr_yvi_a0YZEs": {
+    "title": "Release Strategies",
+    "description": "Release strategies play a critical role in the responsibilities of a Product Manager. Essentially, a release strategy defines the plan for the distribution of the final version of a product. The role of the Product Manager here is to ensure that new releases deliver on the product vision while meeting business objectives. They must carefully plan and manage product releases, outlining what features will be delivered, deciding on the release date, coordinating the teams involved and ensuring the product is effectively launched into the market. An effective release strategy is crucial to achieve the product goals and maximize the value delivered to the customers and business alike.",
+    "links": []
+  },
+  "7BCnM9A9PwYqsLmcNVfvt": {
+    "title": "Feature Toggles",
+    "description": "Feature toggles, also known as feature flags, are a powerful technique giving product managers an advanced control over the features of the product which are visible to specific users. It allows teams to modify a software system's behavior without necessarily changing the code. Feature toggles provide the flexibility of enabling or disabling certain parts of the application, facilitating testing, continuous deployment and facilitating roll-out or roll-back of features. As a product manager, understanding the use of feature toggles is crucial in efficiently managing the release process and reducing risks associated with deploying new features.",
+    "links": []
+  },
+  "8_VCWpSZkRWmsD1_thMYS": {
+    "title": "Phased Rollouts",
+    "description": "Phased rollouts refer to the strategy of gradually introducing a new product or service in the market. As a Product Manager, adopting a phased rollout approach is crucial as it allows the identification and resolution of potential issues in real-time, without impacting the entire user base. Additionally, it provides an opportunity to garner early feedback for improvements before a product is fully launched to the entire market. This strategy helps in minimizing risks as well as ensuring a smooth user experience. The valuable insights gained during this process aids the Product Manager in refining the product and building better solutions.",
+    "links": []
+  },
+  "aCoVHIAZllwKckkkwExR7": {
+    "title": "Dark Launches",
+    "description": "Dark Launches are a valuable strategy in product management. Essentially, they refer to the release of features to a subset of users before the official launch. These unannounced releases, invisible to the majority of users, provide product managers crucial data about how the feature functions in a live environment. They enable product managers to observe real user interactions, gather feedback, identify bugs and areas of improvement prior to a broad scale rollout. This greatly reduces the risk of encountering major issues post-launch and helps ensure a smoother user experience, making dark launches a critical weapon in a product manager's arsenal.",
+    "links": []
+  },
+  "RfllpwFxWBeHF29oUwGo_": {
+    "title": "Key Product Metrics",
+    "description": "Key Product Metrics are essential parameters that Product Managers use to measure the performance and success of a product. These set of metrics help understand the usage, engagement, and overall value of a product to its users. Product Managers rely on these insights to inform their decision-making process, prioritize features, identify areas for improvement and evaluate the impact of changes made to the product. From user acquisition and retention rate to churn rate and time spent on product, choosing the right metrics is vital for driving growth and achieving product goals.",
+    "links": []
+  },
+  "g2EgVtqwQxLfjBjomUqcU": {
+    "title": "DAU (Daily Active Users)",
+    "description": "For a Product Manager, understanding the significance of DAU or Daily Active Users is crucial. DAU is a key product metric used in the tech industry to measure the success of a product. It refers to the number of unique individuals who interact with a product or service on a daily basis. This insight helps product managers understand how compelling and sticky a product is and provides valuable data for making strategic product decisions. Monitoring and analyzing DAU trends can assist in identifying potential issues, measuring user engagement, or capturing growth opportunities.",
+    "links": []
+  },
+  "Sbi5Y72nU_B1Jk6xNp17u": {
+    "title": "MAU (Monthly Active Users)",
+    "description": "MAU (Monthly Active Users) is a critical performance metric that product managers often use to gauge the user engagement and growth of a digital product such as a mobile app, a SaaS product, or a website. It refers to the unique users who engage with the product at least once within a month. As a product manager, understanding the MAU helps in designing effective marketing strategies, making product enhancements, and ultimately driving the product's success.",
+    "links": []
+  },
+  "avkgeNNVQOCE7dvEKFVZv": {
+    "title": "Conversion Rate",
+    "description": "The Conversion Rate is a crucial product metric for any Product Manager. It is the percentage of users who complete a desired action on a product or service, such as making a purchase, signing up for a trial, or subscribing to a newsletter. Monitoring conversion rates allows Product Managers to understand how effectively their product is meeting target audience needs, achieving business goals, and driving desired customer behaviors. It helps in identifying areas of improvement, opportunities for growth, and impact of changes on user interactions.",
+    "links": []
+  },
+  "mfG1UheUwzO8dbS4oglgo": {
+    "title": "Retention Rate",
+    "description": "For a product manager, understanding the retention rate is integral to making key business decisions. This metric refers to the percentage of customers who continue to use a specific product over a given time period. By closely monitoring the retention rate, product managers can gauge the degree to which the product, application, or service meets the needs and expectations of consumers. Low retention rates may indicate dissatisfaction or competition, while high retention rates can suggest user satisfaction and loyalty. Understanding this figure can provide insights into changes that can improve customer engagement and satisfaction, making it a vital aspect of a product manager's role.",
+    "links": []
+  },
+  "jRWVaNpTfBXVjpi4WNT7H": {
+    "title": "Churn Rate",
+    "description": "Churn Rate is a pivotal term in the world of Product Manager. While understanding key product metrics, the term churn plays a significant role. It is the measurement of the percentage of customers or users who leave a product over a given period of time, divided by remaining customers. For example, if you start your month with 100 users and end with 90, your churn rate is 10%. Keeping a low churn rate can signify that customer satisfaction is high, sustaining customer loyalty and fostering conditions for growth. As a Product Manager, understanding, measuring and acting to reduce churn rate is critical to product strategy and overall business sustainability.",
+    "links": []
+  },
+  "DB-dN0bfG29Xv_a8iV8Yg": {
+    "title": "LTV (Lifetime Value)",
+    "description": "The Lifetime Value (LTV) of a customer is a crucial metric for a Product Manager. In its simplest form, LTV is the total revenue a company can expect from a single customer over the duration of their relationship with the company. It's a long-term perspective that ties together the upfront costs of customer acquisition with the ongoing costs of retention and the revenue generated by the customer. With a deep understanding of LTV, Product Managers can make informed decisions about marketing spend, product development, customer retention strategies, and more.",
+    "links": []
+  },
+  "kVd36zDyjLvVG2Nw9gsXi": {
+    "title": "CAC (Customer Acquisition Cost)",
+    "description": "Customer Acquisition Cost (CAC) is a fundamental concept in business and specifically, a significant metric for Product Managers to monitor and optimize. Essentially, CAC is the total cost incurred to acquire a new customer, including all the product, research, marketing, and other associated costs. It provides valuable insight about the efficiency and effectiveness of a company's customer acquisition strategies. In the realm of a Product Manager, understanding and managing CAC is key to ensure that the product's value proposition is being communicated effectively, while also staying profitable and scalable. Hence, a detailed understanding and continuous tracking of CAC is an integral part of effective product management.",
+    "links": []
+  },
+  "MYKZIDHSIXr-69BdtFcNR": {
+    "title": "North Star Metric",
+    "description": "The North Star Metric is a pivotal element of product management, providing a guiding light for strategic decision-making. This critical value speaks to the core value that a product delivers its customers. As a product manager, identifying, tracking, and improving the North Star Metric is essential to cultivating product growth and enhancing user satisfaction. This metric shines a light on the product’s mission, assisting product managers in sharpening the focus on what truly matters for the product's success and lasting impact on users.",
+    "links": []
+  },
+  "eO7glnL0HixQYnoF3uvSW": {
+    "title": "Data-Driven Decision Making",
+    "description": "As a product manager, having a good grip on data-driven decision making is a pivotal skill to have. It is a process where decisions are made based on actual data rather than intuitions or observations. This process helps product managers evaluate where the product stands in terms of its effectiveness, performance, and reception in the market. Decisions are then made about the product's future based on this analysis - whether it needs improvements, new features, or a different marketing approach. By focusing on data-driven decision making, product managers can make choices that are more likely to bring in positive results and reduce risks associated with intuition-based decision making.",
+    "links": []
+  },
+  "V3yGVN7z_ihLkScO0_92_": {
+    "title": "A/B Testing",
+    "description": "The role of a Product Manager often requires making informed decisions to improve product performance and user experience. This is where A/B Testing, a vital aspect of data-driven decision making, comes into play. A/B Testing, also known as split testing, involves comparing two versions of a webpage, ad, or other product experience to see which performs better. It is a methodical approach that enables product managers to determine the impact of changes and make data-driven decisions. It helps reduce the inherent uncertainty in introducing new features or changes and is a key tool in the product manager's arsenal.",
+    "links": []
+  },
+  "APdoU9kzHEqpUgKGKfyp9": {
+    "title": "Cohort Analysis",
+    "description": "Cohort Analysis is a valuable tool in a Product manager's data-driven decision-making toolkit. This specific kind of analysis divides a product's user base into related groups. It's not strictly about the demographics, but rather the shared characteristics within a specific timeframe. These groups, or cohorts, could be determined by the users' behaviors, experiences, or traits. Understanding these cohorts and their behaviors proves to be crucial in identifying trends, predicting user actions, and innovating ways to improve overall user experience and product utility.",
+    "links": []
+  },
+  "YsDt5I0prvYeaFfn4_lpx": {
+    "title": "Predictive Analytics",
+    "description": "In today's fast-paced digital business landscape, it's imperative for a Product Manager to leverage data for driving effective decision-making. This is where Predictive Analytics comes into play. Predictive Analytics employs statistical algorithms and machine learning techniques to determine the likelihood of future outcomes based on historical data. For Product Managers, this powerful tool allows them to anticipate customer behavior and market trends, inform planning and prioritization, and ultimately enhance their product's value proposition. This proactive approach can markedly reduce risks while maximizing opportunities for enterprise growth and customer satisfaction.",
+    "links": []
+  },
+  "kirIe5QsxruRUbWGfQtbD": {
+    "title": "Feedback Loops",
+    "description": "Feedback loops play a vital role in product management. As a product manager, instituting a feedback loop in your workflow is essential in enhancing product quality, user satisfaction, and team performance. This iterative, systematic process involves various stakeholders, including customers, team members, to deliver their insights about the product or service. These insights are critical as they can significantly influence decision-making, product strategy, and future development. Understanding and implementing feedback loops lead to continuous improvement and guide a product manager in successfully driving the product towards its ultimate vision.",
+    "links": []
+  },
+  "5-4MXlRjH-4PlF2giZpVL": {
+    "title": "Communication Skills",
+    "description": "Communication Skills are crucial for a product manager as they act as the bridge between different stakeholders such as development, design, marketing, and executives. Effective communication enables a product manager to share their visions, align the team towards common goals, and articulate stakeholder needs clearly. These skills help to prevent misunderstandings and conflicts, ensuring the successful implementation of product strategies. Without efficient communication skills, a product manager will struggle to convey their ideas, which can ultimately lead to ineffective strategies and unsuccessful products.",
+    "links": []
+  },
+  "O5Ipa7PHeXUNEjQ6Mla7Y": {
+    "title": "Interpersonal",
+    "description": "Interpersonal skills are a quintessential requirement for a Product Manager. They involve the ability to effectively communicate, facilitate, empathize, and interact with different stakeholders. As a Product Manager, one has to frequently collaborate with diverse teams such as design, marketing, sales, and development. Hence, having robust interpersonal skills are critical for maintaining healthy relationships, overcoming hurdles, and driving successful product outcomes. They aid the Product Manager in gaining buy-in for strategic decisions, resolving conflicts, and leading the team towards a common vision.",
+    "links": []
+  },
+  "LPiCtvd00hWsCAefTIUxy": {
+    "title": "Business",
+    "description": "As a Product Manager, having a comprehensive understanding of the business is essential. Business knowledge can help the Product Manager to make better decisions regarding the product direction, market needs, and resource allocation. It encompasses having a clear understanding of the company's business model, financials, competitive environment, and corporate strategy. Furthermore, a business-oriented Product Manager can effectively balance the conflicting needs of the customers, the business, and the product, driving maximum value. This topic, `Business for Product Managers`, emphasizes the importance of business acumen for Product Managers.",
+    "links": []
+  },
+  "XGnJUxZu7_WnPkklvROon": {
+    "title": "Communication Techniques",
+    "description": "Product management is not just about understanding and planning products or services. As a Product Manager, mastering effective communication techniques is key to your success. This involves not only sharing your own ideas, but also actively listening, facilitating discussion, confronting issues, and influencing stakeholders. Mastering these skills helps to rally your team around a shared vision, keep stakeholders informed, and ensure that everyone is working toward the same objectives. This includes communication with diverse audiences such as development teams, designers, sales, marketing and alike. With effective communication techniques, a Product Manager can streamline collaboration, speed up decision-making, and avoid misunderstandings.",
+    "links": []
+  },
+  "iWCcvEEllfACoaXm5Ul5D": {
+    "title": "Difficult Conversations",
+    "description": "In the world of product management, navigating difficult conversations is an unavoidable part of the job. Product Managers often find themselves in challenging discussions with stakeholder, developers, sales teams, and even customers. These conversations can revolve around product expectations, timelines, resource allocation, and a multitude of other issues. Effectively handling these difficult talks while maintaining strong relationships is vital for a successful product journey. That's why, mastering the art of managing and resolving these talks in an efficient, respectful, and productive manner is an essential skill for every Product Manager.",
+    "links": []
+  },
+  "FwYc1942Z0_KYih0BQ1CL": {
+    "title": "Active Listening",
+    "description": "Active Listening is a fundamental skill for a Product Manager. It involves giving full attention to the speaker and showing interest in the information provided. This encompasses comprehending, retaining, and effectively responding to the speaker. For a Product Manager, Active Listening is crucial for understanding the requirements of customers, stakeholders, and team members. It enables a comprehensive understanding of user needs and promotes inclusive decision-making while formulating product strategies.",
+    "links": []
+  },
+  "sQvkXvluZHgTIGS7W3Fj4": {
+    "title": "Conflict Resolution",
+    "description": "As a critical element in the Product Manager's skillset, conflict resolution revolves around mediating disagreements and facilitating solutions that benefit all parties involved. Product Managers often need to balance varying views, conflicting priorities, and different personality types within cross-functional teams. As such, the ability to navigate and resolve conflicts effectively becomes essential for the progress of the product and the harmony of the work environment. Key elements of conflict resolution for Product Managers may include active listening, effective communication, problem-solving strategies and negotiation techniques.",
+    "links": []
+  },
+  "D5GXDeApGwjmLG2-KF2pr": {
+    "title": "Alignment & Buy-In",
+    "description": "Alignment and Buy-In is a crucial aspect of product management. As a Product Manager, one needs to ensure that the team is aligned with the product vision and roadmap. This involves gaining buy-in from key stakeholders, including those at higher levels (executives, CEOs) and those working on the product directly (designers, developers, etc). An effective Product Manager is skilled at presenting compelling arguments to win the support of different stakeholders, fostering a shared understanding of objectives, and ensuring that everyone is onboard and enthusiastic about the product's success. This dynamic involves communication, leadership, negotiation, and persuasion skills.",
+    "links": []
+  },
+  "XxeB3t8MjTbUzZj2hdKF3": {
+    "title": "Showing Impact",
+    "description": "As a Product Manager, one of the essential skills to possess is the ability to demonstrate the impact of the product in the market or to the organization. It involves quantifying and presenting the value and success created by the product through metrics such as sales, customer adoption, or even impact on brand, customer satisfaction, or social responsibility. Showing impact is not just about reporting success, it's also a valuable tool for securing resources, influencing stakeholders, shaping strategy, and fostering a performance-driven culture within the team and company. To effectively show impact, a Product Manager needs a deep understanding of the business model, the market, and the key performance indicators that actually matter to the organization and stakeholders.",
+    "links": []
+  },
+  "X-2mVBut_pn4o_fEGVrib": {
+    "title": "Managing Stakeholders",
+    "description": "As a Product Manager, managing stakeholders is one of the most essential and challenging aspects of your role. Stakeholders include anyone who has an interest in the product, its development, and its success. This could range from executive leadership and different teams within the company to clients, users, and even investors. Successful stakeholder management involves understanding the needs and concerns of stakeholders and effectively communicating with them, navigating conflicting interests, and managing expectations. It requires a balanced approach that ensures the interests of all stakeholders align with the overall product strategy and objectives.",
+    "links": []
+  },
+  "Cryuk9pCI3y78HDGv6TMK": {
+    "title": "Identifying Stakeholders",
+    "description": "As a Product Manager, it's crucial to identify key stakeholders who have a direct or indirect influence on the product's success. These stakeholders can include anyone from customers, team members, organizational leadership, to external business partners. Identifying stakeholders at an early stage can assist in getting their support, understanding their expectations, and mitigating any potential risks they may pose to the product life cycle. It's not only understanding who your stakeholders are, but also their interests, power dynamics, and their potential influence on the product’s success. This process is an essential foundation for effective stakeholder management and ensures alignment across the organization in terms of product vision and objectives.",
+    "links": []
+  },
+  "bHA-9gQhvjh40Cy8jbI9u": {
+    "title": "Stakeholder Mapping",
+    "description": "Stakeholder mapping is a crucial aspect of product management. It is the process by which a product manager identifies and categorizes the individuals or groups that have a vested interest in the product's development and its overall success. These stakeholders could be internal, such as team members, or external like clients, end-users or strategic partners, each bringing in their unique perspectives, expectations, and requirements. A well-conducted stakeholder mapping helps product managers better understand the influence and impact of each stakeholder, manage their expectations, and effectively communicate throughout the product life cycle.",
+    "links": []
+  },
+  "rvqZRvbt73BY5X98dA3Sq": {
+    "title": "Stakeholder Engagement",
+    "description": "Stakeholder engagement is an essential function for a product manager. It involves the identification, communication with, and management of individuals or groups who have an interest or are affected by the products being developed or managed. This could range from internal teams like design, development, and marketing to external entities like customers, partners, and regulators. A product manager must effectively engage stakeholders to understand their needs and concerns, gather valuable inputs, align the product vision, and eventually drive product success.",
+    "links": []
+  },
+  "QGAb7dQM052XPA0Ll-R1P": {
+    "title": "Remote Stakeholders",
+    "description": "The role of a Product Manager involves not only managing a product but also interacting and coordinating with diverse stakeholders. Working with remote stakeholders is a common scenario that Product Managers encounter in their work life. Stakeholders could range from engineers based in different locations, sales teams distributed globally, or even customers who could be states or continents away. The nuances of managing these remote stakeholders, understanding their requirements and expectations, communicating effectively despite time zone differences, and creating a synergy towards a common goal are crucial elements in the role of a Product Manager. Getting it right often results in well-executed projects and stellar products.",
+    "links": []
+  },
+  "XG-QBb--HXL-1r-jInYDN": {
+    "title": "Roadmapping Tools",
+    "description": "Every exceptional product manager understands the crucial role that product roadmaps play in the successful coordination and execution of product strategy. Roadmapping tools often come into play here, as they help simplify complex processes, while enhancing communication and transparency among teams. These tools deliver visually compelling, data-supported product maps, offering an easy-to-understand view of the prioritized features, projected timelines, strategic alignment, and progress tracking. By utilizing such applications, product managers are not only able to manage and communicate their strategy effectively, but also prioritize requests, track progress, and adjust plans based on insights.",
+    "links": []
+  },
+  "Yjxk2gUi5jQONeLzBaeJz": {
+    "title": "Project Management Tools",
+    "description": "As a Product Manager, the utilization of project management tools is vital to effectively oversee and organize various products within a project lifecycle. These tools aid in planning, delegation, tracking, and reporting of tasks, all of which are crucial in managing a product. They bring structure to large scale projects by providing a visual overview of progress, aligning team members, and ensuring timely completion. Whether it's cultivating roadmaps or highlighting dependencies, Project Management tools serve as an indispensable asset for Product Managers.",
+    "links": []
+  },
+  "lJ_7-oYaFWST8aBd5lIgM": {
+    "title": "Analytics Tools",
+    "description": "Product Managers, being key decision-makers in the product life cycle, need to have a deep understanding of their product’s performance. For this, they rely heavily on data. This is where Analytics Tools come into play. These tools provide critical insights into user behavior, product usage, and market trends, which help product managers to make data-driven decisions. They range from user analytics tools to business intelligence platforms, each providing different perspectives of data. Mastering these tools is a fundamental aspect of becoming an effective product manager.",
+    "links": []
+  },
+  "IAta7OX7pAxUzkFdHibY9": {
+    "title": "Communication Tools",
+    "description": "As a Product Manager, communication is a vital tool to effectively manage and execute projects. Product Managers usually deal with complex challenges, multiple stakeholder groups, and shifting priorities, thus the effective use of communication tools is crucial. Communication tools, such as emails, meetings, messaging apps, video conferencing tools, project management apps, and more, are used to ensure everyone on the team remains aligned on key objectives, deadlines, and deliverables. By leveraging these tools, a Product Manager can provide clear instructions, set expectations, collect feedback, and ensure transparency and collaboration among team members.",
+    "links": []
+  },
+  "70yvt_oKcadnjZgg8FtAh": {
+    "title": "Product Board",
+    "description": "Product Board is a strategic tool that serves as a backbone in the realm of product management. Known for its compelling visual environment, it is widely used to cater decision-making processes and hare insights about the product roadmap. It acts as a guidance system for product managers to prioritize the high-impact assignments and deliver meticulously crafted, user-centric products. Able to integrate with other popular platforms, Product Board offers a seamless user experience with its powerful features to bridge the gap between strategy, execution, and team alignment. Excellent facilitator for feedback management, user segmentation, and iterative planning, it is a must-have tool for every agile product manager.",
+    "links": []
+  },
+  "dr5BLjsZXk50R7vp3cMsu": {
+    "title": "Aha",
+    "description": "Aha, as a roadmapping tool, is an indispensable toolset in the arsenal of a Product Manager. It's a comprehensive product management suite that focuses on strategy and roadmapping. Its ability to build visual roadmaps, prioritize features, capture ideas, and define requirements makes it one of the most widely used product management tools. As a product manager, mastering Aha can enable you to envision and articulate strategic product plans while staying aligned with your company's goals.",
+    "links": []
+  },
+  "dk1YzX84UUe_es1x-dfp2": {
+    "title": "Notion",
+    "description": "As a Product Manager, Notion is an indispensable tool in your arsenal for creating roadmaps. This powerful platform is a combination of note-taking, database, project management, and much more. With Notion, you can track the progress of various product initiatives, communicate status updates to stakeholders, and clearly lay out the strategic path ahead. With its flexible, customizable interface and integrations with other useful tools, it is perfectly suited towards collating and synthesizing large amounts of information, which is central to effective product management. The visual nature of Notion's interface makes it particularly well suited for creating compelling, easy-to-understand roadmaps.",
+    "links": []
+  },
+  "EPQ4-cKr-RqJ457XniP6w": {
+    "title": "Jira",
+    "description": "The role of a product manager often calls for effective project management tools, and one of the most prominent among them is Jira. Developed by Atlassian, Jira is a versatile platform that allows product managers to plan, track, and release top-class software. It's cherished for its user-friendly interface and capabilities to create user stories, plan sprints, and distribute tasks across teams. As a product manager, understanding and utilizing Jira enhances the tracking of issues and workflows, aiding in efficient product development and team collaboration. Moreover, Jira's extensive features and customization options make it an indispensable tool in a product manager's arsenal.",
+    "links": []
+  },
+  "PIIGfDN6t8H6tXZuKuE04": {
+    "title": "Linear",
+    "description": "Linear is a powerful project management tool designed to help teams improve their productivity and efficiency. It helps organize, prioritize, and track tasks in one streamlined platform. For the role of a Product Manager, Linear is an essential tool that aids in managing and monitoring progress, evaluating performance, and ensuring the roadmap aligns with the strategic goals of the product. Product managers may utilize the functionalities of Linear to communicate with various stakeholders, delegate tasks, and manage product backlogs effectively. Its clean and user-friendly interface makes it easy for Product Managers to streamline their workflow and focus more on building high-quality products.",
+    "links": []
+  },
+  "SD98_s1ET_j2eIIKmcKRc": {
+    "title": "Trello",
+    "description": "Product management entails numerous responsibilities, among which is managing several tasks, teams and deadlines to make sure that products are developed and launched on time. To effectively manage these responsibilities, Product Managers often require robust Project Management Tools. One such tool is \"Trello\".\n\nTrello is an easy-to-use, highly visual tool that aids in organizing projects into boards. It provides an overview of what's being worked on, who is working on what, and how far they've proceeded with their tasks. For Product Managers, Trello can be a substantial asset in managing tasks, collaborating effectively with team members, and ensuring transparency in progress tracking. Overall, Trello can increase productivity and simplify the intricate nature of product management.",
+    "links": []
+  },
+  "Z5oorppEJ0ydvwMXSlk1J": {
+    "title": "Amplitude",
+    "description": "Amplitude is an exceptional analytical tool that offers in-depth insights about user behavior, allowing product managers to optimize their products based on real-time data. Equipped with features like funnel analysis, retention analysis, and user segmentation, Amplitude provides an essential understanding of how users interact with products. For product managers, understanding these interactions is crucial in decision-making, prioritizing product improvements, and enhancing the overall user experience. Thus, Amplitude serves as a valuable resource for Product Managers looking to drive product growth and maximize user engagement.",
+    "links": []
+  },
+  "xas-t2sAKmJNfb0-Zcpwy": {
+    "title": "Heap",
+    "description": "Heap Analytics is a robust solution for product managers looking to gain actionable insights into their product's usage and performance. It's a powerful analytics tool that allows the automatic capturing of every user interaction across the entire customer journey. From clicks and taps to form submissions and transactions, Heap captures all data without needing any pre-defined tracking set-up. As a Product Manager, understanding the value that Heap brings in effortlessly tracking user engagement and offering data-driven insights is integral for refining product decisions and driving the overall product strategy.",
+    "links": []
+  },
+  "y8Ys_WfPXLVfJngOLryGR": {
+    "title": "Looker",
+    "description": "Looker is a modern, cutting-edge data platform that provides robust tools for business analytics. As a Product Manager, understanding and utilizing Looker becomes significant since it enables data-driven decision-making. This tool facilitates comprehensive data exploration, interactive dashboard creation, and sharable reporting, which helps in managing product strategies effectively. Familiarity with Looker's capabilities thus empowers a product manager to explore markets, understand user behaviors, and ultimately define successful products.",
+    "links": []
+  },
+  "UdOJDzkDP_R3E5f_IltYh": {
+    "title": "Slack",
+    "description": "As a product manager, effective communication with different stakeholders is a crucial task. Slack emerges as an essential platform for this role. It is a cloud-based team collaboration tool that facilitates quick and efficient communication among team members, from developers and marketing professionals to various stakeholders. This platform also integrates with a variety of other tools that product managers use regularly, thereby acting as an operational hub for project management. Product managers can create channels on Slack for different projects or topics to ensure organized and focused conversations. It also supports direct messaging and file sharing which enhances day-to-day communication and coordination.",
+    "links": []
+  },
+  "z72akk5E5XjEuLraS9Gug": {
+    "title": "Teams",
+    "description": "In the landscape of product management, communication plays an extraordinary role and Microsoft Teams is one of the most pivotal communication tools in this aspect. A product manager often engages with diverse teams - engineering, design, marketing, sales, and more, ensuring coherence and alignment towards the product vision. The Microsoft Teams platform boosts this communication process, providing a centralized space for conversations, content, meetings, and tasks. Its features like chat, video meetings, file sharing, and integration with other tools significantly streamline collaboration and decision-making, which are integral to a product manager's role.",
+    "links": []
+  },
+  "e6gO1twjter9xWm14g9S9": {
+    "title": "Discord",
+    "description": "Discord is a widely used communication tool that is beginning to make its mark in the field of product management. It offers a secure and user-friendly platform with features that are quintessential for a Product Manager. With its rich text chats, voice channels, and ability to create multiple channels with different access levels, it ensures seamless communication within cross-functional teams. For Product Managers, Discord can be an essential collaboration tool that aids in the exchange of innovative ideas, constructive feedback, and bug reporting, thereby allowing them to design, plan, and execute with efficiency.",
+    "links": []
+  },
+  "oO-ujKApmpoQdkPEkOQG7": {
+    "title": "Identifying Risks",
+    "description": "Risk identification is a critical component in the role of a Product Manager. It involves determining potential threats that could negatively affect the success of a product. These risks could exist in various circumstances, including development, marketing, sales, or even post-launch.\n\nA Product Manager must be vigilant in recognizing these potential hazards as early as possible in the product lifecycle. This not only involves identifying the risks, but also analyzing and prioritizing them for further action. By doing so, the Product Manager aids in creating risk mitigation strategies, contributing to the overall product strategy and ensuring the success of the product in the market.",
+    "links": []
+  },
+  "0zRGIArMUe9xVDSKfnoHZ": {
+    "title": "Risk Identification Techniques",
+    "description": "Risk identification techniques are critical tools used by Product Managers to anticipate potential obstacles and take preventative measures in product development lifecycle. They involve various methods to identify possible risks that could negatively impact the realization of the product’s goals. Early detection of risks allows for proper risk management and mitigation, thus ensuring a smooth and successful product launch. These techniques can range from brainstorming sessions and scenario analysis to risk checklists and assessment workshops. Understanding these methodologies is vital for any Product Manager aiming for effective product management and successful project outcomes.",
+    "links": []
+  },
+  "WBnLicFo9p2zm57pyXciI": {
+    "title": "Risk Register",
+    "description": "The Risk Register is an important tool for Product Managers as it systematically identifies and manages potential issues that could negatively impact the outcome of a product's development. It consists of a log of potential risks, quantifying their impact, likelihood, and mitigation strategies. This essential document allows Product Managers to prioritize strategies, allocate resources more efficiently, and develop contingency plans. In essence, a Risk Register helps Product Managers to better anticipate, assess, and prepare for the potential bumps on the road to successful product delivery. It encourages a proactive rather than reactive approach to managing risk, contributing to overall product success.",
+    "links": []
+  },
+  "0uRTNYMwTU9JzvIWSvDSm": {
+    "title": "Risk Assessment",
+    "description": "Risk Assessment is an essential tool in the lifecycle of product management. It involves the identification and analysis of potential risks that could negatively impact key business initiatives or critical projects. As a Product Manager, understanding and managing these risks can not only prevent potential issues but also prepare the team with strategic solutions to counteract them. Implementing effective risk assessment can result in improved product quality, reduced costs, and increased stakeholder satisfaction. It is a dynamic process that should be revisited throughout the product development process to minimize threats and maximize opportunities.",
+    "links": []
+  },
+  "KXadmIkKJM0XLV4Qz0Stj": {
+    "title": "Qualitative Risk Assessment",
+    "description": "Qualitative Risk Assessment is a crucial aspect of a Product Manager's role. It involves evaluating potential risks according to their likelihood and potential impact, rather than using exact numerical measurements. This subjective assessment aids in prioritizing risks that could impact product development and helps implement necessary mitigation strategies. Product Managers need a profound understanding of qualitative risk assessment to successfully navigate the complexities of product management, ensuring the product's success while considering all possible risk factors.",
+    "links": []
+  },
+  "g0sBLcG8kEfeHHtsJSb4i": {
+    "title": "Quantitative Risk Assessment",
+    "description": "Product Managers are often required to make important decisions which can significantly affect the success of a product. One of the key decision-making tools they use is Quantitative Risk Assessment (QRA). QRA is a formal and systematic approach to estimating the probability and consequences of potential product risks. It involves the use of objective and empirical data to calculate the likelihood of a risk occurring and the magnitude of its impact. This methodology provides Product Managers with a data-driven framework to identify, assess, and prioritize risks, enabling them to make informed product decisions and to develop effective risk mitigation strategies.",
+    "links": []
+  },
+  "A-srndVB0olGq0qkApnwi": {
+    "title": "Risk Mitigation",
+    "description": "Risk Mitigation plays an essential role in the realm of Product Management. It's the responsibility of a Product Manager to anticipate potential pitfalls and create strategies to minimize their impact on the product's development and lifecycle. It requires a deep understanding of the project's scope, stakeholders' expectations, market trends and potential technical constraints. By intimately knowing the product and the environment in which it operates, a product manager can effectively strategize against any risk and ensure that the product stays on its intended course towards success.",
+    "links": []
+  },
+  "4gV80Qrd08_Y8oZB_hahV": {
+    "title": "Mitigation Strategies",
+    "description": "For a Product Manager, understanding and implementing mitigation strategies is crucial in the development and lifecyle of a product. These strategies help to prevent, manage, and respond to risks that may arise during the product's development cycle. Acquiring the ability to identify potential risks and planning appropriate countermeasures is a fundamental skill required by Product Managers to ensure the successful launch and sustainability of a product in the market. The process often includes stages such as risk identification, risk assessment, and the development and execution of risk control strategies.",
+    "links": []
+  },
+  "ybq-zRDLvtTTl8X8GnRNf": {
+    "title": "Contingency Planning",
+    "description": "Contingency planning constitutes an integral part of risk mitigation strategies for any Product Manager. It involves identifying potential risks and developing plans to prevent, respond to, or minimize the impact of those risks on the product development process. For a Product Manager, contingency planning entails envisioning various scenarios that could lead to setbacks in the delivery of the product and devising alternate plans. This acts as a safeguard to ensure smooth operations and delivery of the product on time, catering to user expectations. It provides a roadmap to manage unforeseen problems and reduces potential losses by maintaining the consistency and quality of the product.",
+    "links": []
+  },
+  "zJGg20NPStLPkeL5LKoGm": {
+    "title": "Monitoring and Controlling Risks",
+    "description": "In the realm of product management, monitoring and controlling risks is a critical responsibility. This process entails identifying potential areas of risks in product development and implementing strategies to mitigate them. Consequently, it involves continuous vigilance to ensure that potential threats do not escalate into problems that could jeopardize the success of the product. Product managers are often tasked with predicting likely risks, developing contingency plans and ensuring contractual compliance to keep the product development process smooth and within specified constraints. Their role hence extends beyond mere product vision and development, into a vital aspect of business strategy and risk management.",
+    "links": []
+  },
+  "S2w72SRx-9QvRO7RNBlKZ": {
+    "title": "Risk Monitoring Tools",
+    "description": "As a Product Manager, one of the key responsibilities is understanding and managing risks associated with the product. Risk Monitoring Tools play an integral role in this process. These tools are specialized software designed to identify, assess, track, and mitigate risks in product development and releases. They provide data-driven insights on potential hazards, allowing product managers to make informed decisions and implement strategies to prevent or minimize risk impacts. These tools can help in tracking the progress of risk resolution, visualize risk prioritization, and alert the product managers about the upcoming risks in time.",
+    "links": []
+  },
+  "ao2uUq_UZWtB-LRKH1x40": {
+    "title": "Risk Audits",
+    "description": "Risk audits form an integral part of the product management process. As a Product Manager, conducting risk audits involves comprehensive assessment of the various potential risks associated with the development and launch of a product. These risks could range from functional issues, design flaws, marketing challenges, to various other uncertainties that may potentially impact the success of a product. Risk audits aim to identify these threats ahead of time, mitigate them effectively, and devise strategies to turn these risks into opportunities. This rigorous process helps a Product Manager to ensure the smooth continuity of production, enabling robust, timely, and financial-efficient deployments of products.",
+    "links": []
+  },
+  "4i_kX9oZunMBFYevu7lyi": {
+    "title": "Scaling Products",
+    "description": "Scaling products is a crucial responsibility of a Product Manager. It involves optimizing a product's infrastructure and processes to cater to an increasing number of users or requests, without compromising on its efficiency or functionality. This process not only involves improving actual product features but also business strategies such as go-to-market plans, revenue models, and customer relations. A successful Product Manager has a specific scale-up strategy in place, effectively enabling product growth while managing potential risks. Being able to scale products successfully is a hallmark of a successful product, crucial to the company's long-term sustainability and profitability.",
+    "links": []
+  },
+  "4-w4BpDh4dpmnU9qfjqbU": {
+    "title": "Growth Strategies",
+    "description": "For a Product Manager, successful growth strategies are key to the scalability and survival of a product in the long run. They are charged with defining the direction and vision of the product, which includes implementing robust growth strategies. These strategies could range from market penetration, market development, product development to diversification. These strategic decisions directly affect the product's market share, competitiveness, and profitability. A well-versed Product Manager should understand these strategies and how to effectively deploy them based on the product's lifecycle, customer insights, competitive analysis, and market conditions. It is critical for the product manager to be in sync with cross-functional teams including Sales, Marketing, Engineering, Design to implement these growth initiatives effectively and move the product in the intended direction.",
+    "links": []
+  },
+  "lIdogd1DAzCo1ct7cdvYD": {
+    "title": "Internationalization",
+    "description": "Internationalization in product management refers to designing a product in a way that can easily be adapted for various international markets without requiring significant changes. This includes not just language translation, but also dealing with cultural differences, local regulations, and multiple time zones. A Product Manager must consider internationalization to ensure its product appeals to different geographical locations thereby facilitating a wider user base, increased market share, and, potentially, profitability.",
+    "links": []
+  },
+  "EEi56Ww04QbuF2I7B7xW8": {
+    "title": "Platform Thinking",
+    "description": "The role of a Product Manager extends beyond managing individual products. It often involves taking a broader outlook known as Platform Thinking. In the context of product management and particularly in scaling products, Platform Thinking involves considering the product not merely as a standalone offering but as a part of a larger ecosystem. This ecosystem is constituted by other products, services, users, developers, and other actors. A product manager, thus, needs to strategically design, develop, and scale the product in a way that it seamlessly fits into and contributes to the ecosystem, while also gaining valuable inputs and leveraging opportunities originating from the same platform.",
+    "links": []
+  },
+  "BGtxI9CHtJfhRMdUEIfWa": {
+    "title": "Portfolio Management",
+    "description": "Portfolio Management is one of the most critical responsibilities of a Product Manager. It involves the strategic decision-making process aimed at aligning organizational strategy with the efforts of teams tasked with planning, creating, and delivering products. Portfolio management allows product managers to assess how potential products or a set of products can deliver the most value to the company and its customers. Balancing benefits, costs, risks, and resources, while maintaining a keen eye on market trends and competition forms the core of portfolio management for a company. In essence, a Product Manager has to curate the product portfolio in a way that ensures long-term success and growth of a business.",
+    "links": []
+  },
+  "9y_I41kJhkmyBJjiTw8Xd": {
+    "title": "Advanced Analysis",
+    "description": "The field of Advanced Analysis plays a pivotal role in the domain of Product Management. As the driving force behind decision-making, it incorporates sophisticated methods and tools to draw meaning from data, enabling Product Managers to extract actionable insights. This subject involves applications such as Predictive Modeling, Statistical Analysis, and Machine Learning algorithms to yield a deep understanding of user behavior, market trends, product performance and forecast potential outcomes. With the power of advanced analysis, Product Managers can create data-driven strategies, optimize the user experience, and accelerate overall product growth.",
+    "links": []
+  },
+  "h5N51_YgjaTHhPUHxkqQR": {
+    "title": "Predictive Analytics",
+    "description": "Product Management encompasses a plethora of analytical strategies and one of the essential approaches is Predictive Analytics. As a Product Manager, having insights about future outcomes can make a substantial difference in decision-making. Predictive Analytics is leveraged to analyze historical and current data and make predictions about unseen or future events. This can help in efficient planning, risk management, and strategic decision making. It's a powerful tool for product managers that enables them to predict trends, understand user behavior, forecast demand, and ultimately, to build better products.",
+    "links": []
+  },
+  "rzrxYqFENQ3d0WpZv9-0Q": {
+    "title": "ML in Product Mgmt.",
+    "description": "Machine Learning (ML) is revolutionizing various industries and the field of product management is no exception. In a dynamic digital era, product managers are leveraging machine learning techniques to drive product innovation, better understand customer behavior, and forecast trends. With ML, data can be processed at an immense speed allowing product managers to make data-driven decisions and anticipate the future needs of the market, thus creating products that resonate with target audiences. Its contribution to predictive and behavioral analytics, customer segmentation and pricing strategy makes ML an essential tool for modern-day Product Management.",
+    "links": []
+  },
+  "H7sf23kwv73XjnFCdKHPi": {
+    "title": "AI in Product Mgmt.",
+    "description": "Artificial Intelligence (AI) has been increasingly instrumental in shaping the field of product management. As a product manager, it is crucial to comprehend the implications and applicability of AI in managing products effectively. AI can aid in forecasting trends, understanding customer behavior, automating routine tasks and improving decision-making processes. Grasping the full potential of AI can greatly assist product managers in building more effective strategies and in constantly refining their products to meet customer needs. It's a powerful tool that can significantly heighten the intelligence and efficiency of a product environment.",
+    "links": []
+  },
+  "WyKJxhfnbz6jx-Tvg40_j": {
+    "title": "Leadership and Influence",
+    "description": "The roles of a Product Manager extend beyond merely guiding product development. Leadership and influence are integral to a Product Manager's toolkit. With a unique, cross-functional role that interacts with various departments such as design, engineering, and marketing, a Product Manager needs to inspire and mobilize teams towards a singular product vision. Moreover, they must effectively communicate, influence decisions, and advocate for their product in the face of potential resistance, all the while fostering a climate that empowers team members and stakeholders. This underscores the necessity for skills in leadership and influence in product management, underlining its significance beyond technical knowledge and tactical expertise.",
+    "links": []
+  },
+  "MP-jZtofXCufnvtSldxqU": {
+    "title": "Building and Leading Teams",
+    "description": "As a Product Manager, building and leading teams are crucial aspects of one's role. This involves assembling a competent and diverse team and establishing a shared vision and goals. Once the team has been formed, it’s up to the Product Manager to guide, motivate, and manage the team to drive the grand vision into reality. They need to exhibit strong leadership qualities, foster a healthy and collaborative work environment, recognize individual contributions and ensure that every member feels valued for their work. This involves not just managing but also mentoring and empowering the team to take ownership and deliver their best work. This process of team building and leadership directly influences the successful execution of a product's lifecycle.",
+    "links": []
+  },
+  "CMge123Tm9DrZ31LvipLD": {
+    "title": "Influencing without Authority",
+    "description": "As a Product Manager, the ability to influence without authority is a critical skill set. This is often because Product Managers do not necessarily have direct authority over the team yet are expected to guide product strategies and make vital decisions. Influencing without authority involves convincing others to follow your ideas or approach, and can often include multidirectional influence, not just downward but upward and sideways too. A Product Manager navigates between different stakeholders like cross-functional partnerships, sales, marketing, engineering, design, etc., with varying levels of authority. Mastering the art of Influencing without Authority allows Product Managers to motivate and sway these differing parties to work collectively towards a shared vision or goal, thereby driving the product's success.",
+    "links": []
+  },
+  "gyNOziqf1VsfI2j-FaNZ_": {
+    "title": "Emotional Intelligence",
+    "description": "Emotional Intelligence (EI) is vital in every aspect of leadership, and in the realm of product management, it is no less significant. A Product Manager with high emotional intelligence can navigate complex work relationships, make better decisions, maintain morale in their team, and efficiently drive a product from conception to completion. In essence, emotional intelligence shapes a successful Product Manager and contributes to the effectiveness of their leadership. With the ability to identify and handle not only their own emotions, but also those of their team members, Product Managers can create a productive, creative, and resilient working environment.",
+    "links": []
+  },
+  "9vy4uIoykk2zSSyIok4_S": {
+    "title": "Introduction",
+    "description": "The role of a Product Manager is arguably one of the most important in any tech company. Responsible for guiding the success of a product and leading the cross-functional team that is responsible for improving it, a Product Manager is essentially the chief advocate for a product's feature set and overall business value. In fact, a Product Manager often analyzes market and competitive conditions and lays out a product vision that is differentiated and delivers unique value based on customer demands. The role of a Product Manager spans many activities from strategic to tactical and provides important cross-functional leadership — most notably between engineering, marketing, sales, and support teams. As the product's key strategist and advocate, a Product Manager communicates the voice of the customer and strives to maximize the value of their product, for both users and the company.",
+    "links": []
+  }
+}

public/roadmap-content/redis.json

@@ -0,0 +1,929 @@
+{
+  "-3pADOHMDQ0H6ZKNjURyn": {
+    "title": "What is Redis?",
+    "description": "Redis is an open-source, in-memory data structure store, primarily used as a database, cache, and message broker. It supports various data structures like strings, hashes, lists, sets, and sorted sets, making it highly versatile. Redis operates with extremely low latency due to its in-memory nature, enabling fast access to data. It is often used in real-time applications such as session management, leaderboards, or caching mechanisms, where quick data retrieval is critical. Additionally, Redis supports data persistence by periodically writing the dataset to disk, balancing memory speed with data reliability.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "What is redis?",
+        "url": "https://redis.io/docs/latest/get-started/",
+        "type": "article"
+      }
+    ]
+  },
+  "M-EXrTDeAEMz_IkEi-ab4": {
+    "title": "In-memory Data Structure Store",
+    "description": "An in-memory database is a purpose-built database that relies primarily on internal memory for data storage. It enables minimal response times by eliminating the need to access standard disk drives (SSDs). In-memory databases are ideal for applications that require microsecond response times or have large spikes in traffic, such as gaming leaderboards, session stores, and real-time data analytics. The terms main memory database (MMDB), in-memory database system (IMDS), and real-time database system (RTDB) also refer to in-memory databases.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Amazon MemoryDB",
+        "url": "https://aws.amazon.com/memorydb/",
+        "type": "article"
+      }
+    ]
+  },
+  "l2aXyO3STnhbFjvUXPpm2": {
+    "title": "Key-value Database",
+    "description": "Key-value Database is a non-relational (NoSQL) database that stores data as a collection of key-value pairs. In this model, each piece of data is associated with a unique identifier (key) that is used to retrieve the corresponding value. This simple structure allows for high performance and scalability, making key-value databases ideal for certain use cases.\n\nVisit the following resources to learn more:",
+    "links": [
+      {
+        "title": "What is a Key-Value Database?",
+        "url": "https://redis.io/nosql/key-value-databases/",
+        "type": "article"
+      },
+      {
+        "title": "Key Value Store - System Design Interview Basics",
+        "url": "https://www.youtube.com/watch?v=ozJHmm05EXM",
+        "type": "video"
+      }
+    ]
+  },
+  "eHuBz_zSZK3rubn7nkd7g": {
+    "title": "Cache",
+    "description": "",
+    "links": []
+  },
+  "mgGJTBU8ofvOzl9gYWhnG": {
+    "title": "Message Broker",
+    "description": "",
+    "links": []
+  },
+  "-TjnSOY8txYrhhxRV1OIl": {
+    "title": "Caching",
+    "description": "",
+    "links": []
+  },
+  "bVJASI7bfSYqYnNhX83ng": {
+    "title": "Real-time Analytics",
+    "description": "",
+    "links": []
+  },
+  "URxGmhZHr0Y8nyrYj0gJl": {
+    "title": "Session Management",
+    "description": "",
+    "links": []
+  },
+  "ZCyId3aIoLv3duxoJdk2P": {
+    "title": "Pub/Sub Messaging",
+    "description": "",
+    "links": []
+  },
+  "Fv1iGX22sApIEifM2IpJz": {
+    "title": "Leaderboards and Counters",
+    "description": "",
+    "links": []
+  },
+  "8uRpPJ0iD4XnQPKruQc8P": {
+    "title": "Data Persistence Options",
+    "description": "",
+    "links": []
+  },
+  "uVewcyaFi1Pt2Gs0KrkfA": {
+    "title": "Rich Data Structures",
+    "description": "",
+    "links": []
+  },
+  "5-3pd4rLDqRzMzSRVLdXh": {
+    "title": "High Performance and Scalability",
+    "description": "",
+    "links": []
+  },
+  "EvWiEx_AoxAht6sKxzW2l": {
+    "title": "Redis vs SQL/NoSQL DBs",
+    "description": "",
+    "links": []
+  },
+  "1Af5H0BgdAsRdBCNdHz5v": {
+    "title": "When to choose Redis?",
+    "description": "",
+    "links": []
+  },
+  "Bf_kLfmy7_uflqC9N0-jt": {
+    "title": "Using Package Managers",
+    "description": "",
+    "links": []
+  },
+  "yBZ79s6mzGdj5AnX2H_Hy": {
+    "title": "Pre-compiled Binaries",
+    "description": "",
+    "links": []
+  },
+  "TDxv0q7jlZ26uZYYlneem": {
+    "title": "Using Docker",
+    "description": "",
+    "links": []
+  },
+  "43LvShQhmoWQ8Nye7fLkz": {
+    "title": "Starting the Server",
+    "description": "",
+    "links": []
+  },
+  "BOGXTjmCLo6WI6mYDsqRu": {
+    "title": "Connecting using Redis CLI",
+    "description": "",
+    "links": []
+  },
+  "NhcZM4nUQoSBBf_1qXi6l": {
+    "title": "Basic Commands / SET, GET",
+    "description": "In Redis, the SET and GET commands are fundamental operations used to store and retrieve key-value pairs. Redis is an in-memory key-value store, and these commands form the basis for working with data in Redis.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "SET Docs",
+        "url": "https://redis.io/docs/latest/commands/set/",
+        "type": "article"
+      },
+      {
+        "title": "GET Docs",
+        "url": "https://redis.io/docs/latest/commands/get/",
+        "type": "article"
+      },
+      {
+        "title": "Redis command cheat sheet",
+        "url": "https://redis.io/learn/howtos/quick-start/cheat-sheet",
+        "type": "article"
+      }
+    ]
+  },
+  "DOdNkTY1yIMipWA2CD9xH": {
+    "title": "Settings and Getting Keys",
+    "description": "",
+    "links": []
+  },
+  "lV_MnUNTB2h925idX0YWk": {
+    "title": "DEL",
+    "description": "",
+    "links": []
+  },
+  "U84XgBFPyIbY0W5afH4cx": {
+    "title": "Overview of Data Types",
+    "description": "",
+    "links": []
+  },
+  "ltF4vCT9ZA2XuUuHnuGnN": {
+    "title": "SET",
+    "description": "",
+    "links": []
+  },
+  "mQc4H2ZMMSVjh33LJY8mK": {
+    "title": "GET",
+    "description": "",
+    "links": []
+  },
+  "5K9qyC4mrhXYWOC8WSq8C": {
+    "title": "INCR",
+    "description": "",
+    "links": []
+  },
+  "t4BXPofF8OCqH5KHwdYVh": {
+    "title": "DECR",
+    "description": "",
+    "links": []
+  },
+  "cPWd53BO6tm-uy4gqLdtZ": {
+    "title": "APPEND",
+    "description": "Redis APPEND command is used to add some value in a key. If the key already exists and is a string, this command appends the value at the end of the string. If key does not exist it is created and set as an empty string,\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "APPEND Docs",
+        "url": "https://redis.io/docs/latest/commands/append/",
+        "type": "article"
+      },
+      {
+        "title": "Redis - String Append Command",
+        "url": "https://www.tutorialspoint.com/redis/strings_append.htm",
+        "type": "article"
+      }
+    ]
+  },
+  "eJQW986HM4Wf1o1i2FnXs": {
+    "title": "STRLEN",
+    "description": "",
+    "links": []
+  },
+  "0v8uLWRCbAqEmKKdYaRQW": {
+    "title": "More Commands",
+    "description": "",
+    "links": []
+  },
+  "2_E2VwbjTgk4xxTFWfHuV": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "nS0DHhfy4wxHItgOFhulA": {
+    "title": "EXPR",
+    "description": "",
+    "links": []
+  },
+  "Vll7VMmGWSI5XGZ9JpHyl": {
+    "title": "TTL",
+    "description": "",
+    "links": []
+  },
+  "Kq7G89KaZZMFkrH-9WZoS": {
+    "title": "LPUSH",
+    "description": "",
+    "links": []
+  },
+  "jC8G1o7yFj7D_PGmOIgcD": {
+    "title": "RPUSH",
+    "description": "",
+    "links": []
+  },
+  "voa61RTWMJD3Sk8DNJoVQ": {
+    "title": "LPOP",
+    "description": "",
+    "links": []
+  },
+  "brUGqWZ287EWtvl9uUbNt": {
+    "title": "RPOP",
+    "description": "",
+    "links": []
+  },
+  "8JTtBy6oD2wFYDizVkcVa": {
+    "title": "LRANGE",
+    "description": "",
+    "links": []
+  },
+  "hBFEUXtuzUTzWZKp2qWaZ": {
+    "title": "LINDEX",
+    "description": "",
+    "links": []
+  },
+  "4oCcP9FxDJSDMHCEVBCNa": {
+    "title": "LLEN",
+    "description": "",
+    "links": []
+  },
+  "9KvHcS5F4Jj5ZXgIAdOQY": {
+    "title": "LMOVE",
+    "description": "",
+    "links": []
+  },
+  "eBeEUYY-IL_CMkcm31lUL": {
+    "title": "More Commands",
+    "description": "",
+    "links": []
+  },
+  "XTwNCCtzXvZMdaex4gZEh": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "Qgkpr9vf9d6-vUg1o8XFj": {
+    "title": "Sets",
+    "description": "",
+    "links": []
+  },
+  "xUKoQps69FFQrJeuhD1pz": {
+    "title": "SADD",
+    "description": "",
+    "links": []
+  },
+  "mQ0ILns53n1By0Tq6xSZI": {
+    "title": "SMEMBERS",
+    "description": "",
+    "links": []
+  },
+  "WQWVL5GT_scHdgfCtI7WT": {
+    "title": "SREM",
+    "description": "",
+    "links": []
+  },
+  "Ji5ghlcGJtlmErHFqVf3d": {
+    "title": "SISMEMBER",
+    "description": "",
+    "links": []
+  },
+  "5aLfNBewK4Dx017qVNO3T": {
+    "title": "SINTER",
+    "description": "",
+    "links": []
+  },
+  "2gZL4a9aWGKWLa89iyHTc": {
+    "title": "SCARD",
+    "description": "",
+    "links": []
+  },
+  "6QoYa-N2BKNBaRtvNeVNm": {
+    "title": "SUNION",
+    "description": "",
+    "links": []
+  },
+  "JX5ajmcUmkshTO-mLF8lH": {
+    "title": "SDIFF",
+    "description": "",
+    "links": []
+  },
+  "2SG4Hr9Tuv6cxmGkrKjYZ": {
+    "title": "More Commands",
+    "description": "",
+    "links": []
+  },
+  "3hayYoSZepw7pppBubotg": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "b48EUyFGUeSjtT5fOa_m6": {
+    "title": "More Commands",
+    "description": "",
+    "links": []
+  },
+  "Wl23Jh-ASJOQ850yjaTIU": {
+    "title": "Strings",
+    "description": "",
+    "links": []
+  },
+  "4-C4XqACUp4nvcMIj6djF": {
+    "title": "Lists",
+    "description": "",
+    "links": []
+  },
+  "wY46Qj5Inw_ClBNI9PB_2": {
+    "title": "Hashes",
+    "description": "",
+    "links": []
+  },
+  "BOJzn9SWad9oRRdY_ub01": {
+    "title": "HSET",
+    "description": "",
+    "links": []
+  },
+  "MsKg9m5jFwHM2Bzjf-vdu": {
+    "title": "HGET",
+    "description": "",
+    "links": []
+  },
+  "TpR33sJ-tAjeG3jpGTvYR": {
+    "title": "HGETALL",
+    "description": "",
+    "links": []
+  },
+  "E7xFZkqqbzokD5KGTn9zJ": {
+    "title": "HDEL",
+    "description": "",
+    "links": []
+  },
+  "adhLMuSmfYMRyWTwIgnyE": {
+    "title": "HEXISTS",
+    "description": "",
+    "links": []
+  },
+  "jtVnUD-na-WffMaS8qYfu": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "QTbkWZ7BpqYmBhUivccPu": {
+    "title": "Sorted Sets",
+    "description": "",
+    "links": []
+  },
+  "0swsBD0sOY-o5lzibT999": {
+    "title": "ZADD",
+    "description": "",
+    "links": []
+  },
+  "3pFChX6YIItrBz9lxu4XM": {
+    "title": "ZRANGE",
+    "description": "",
+    "links": []
+  },
+  "OlbixGa5RmdqEt7snY04j": {
+    "title": "ZRANGEBYSCORE",
+    "description": "",
+    "links": []
+  },
+  "m0FZDPwNE71zcwM_gUwz0": {
+    "title": "ZREM",
+    "description": "",
+    "links": []
+  },
+  "W4v7FIQr2k-Vbm-HdfKog": {
+    "title": "ZINCRBY",
+    "description": "",
+    "links": []
+  },
+  "AF_kWM4V8n5Ux06IgEVTl": {
+    "title": "ZRANK",
+    "description": "",
+    "links": []
+  },
+  "O-fZM_U-tW0pYtNzN_8Ax": {
+    "title": "ZCOUNT",
+    "description": "",
+    "links": []
+  },
+  "P6TDUCroLlEI7qePBFHIH": {
+    "title": "More Commands",
+    "description": "",
+    "links": []
+  },
+  "lxevY15ZyP43s_JrEqMX7": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "o6e_CwxfPoU6qkfWkwKwj": {
+    "title": "More Commands",
+    "description": "",
+    "links": []
+  },
+  "jCaVx5wvsvuyqtwh6m8si": {
+    "title": "Naming Conventions",
+    "description": "",
+    "links": []
+  },
+  "UlQHqw1dbxZnAKbsWsOgU": {
+    "title": "Retrieval by Pattern",
+    "description": "",
+    "links": []
+  },
+  "OSIYDYPGz8Vgo9SU9GGH9": {
+    "title": "Expiration",
+    "description": "",
+    "links": []
+  },
+  "jrgaoDnt_RxTu79hk4hCD": {
+    "title": "Atomicity in Redis",
+    "description": "Atomicity in Redis refers to the property that ensures a set of operations is executed as a single, indivisible unit. This means that either all the operations are executed successfully or none of them are. Atomicity is crucial in Redis to maintain consistency, especially when multiple operations need to be performed together.\n\nLearn more from the following resources:\n\n*   [@official@Atomicity with Lua](https://redis.io/learn/develop/java/spring/rate-limiting/fixed-window/reactive-lua) -[@article@Atomicity in Redis operations](https://lucaspin.medium.com/atomicity-in-redis-operations-a1d7bc9f4a90)",
+    "links": []
+  },
+  "LHlwjN3WHYUBUafzzwsWQ": {
+    "title": "Pipelining",
+    "description": "",
+    "links": []
+  },
+  "7JzeyTrkZ_1_yxMVrqvZU": {
+    "title": "Batch Operations",
+    "description": "Batch operations in Redis allow you to execute multiple commands efficiently in a single network round-trip. While Redis does not have true batching like some databases (where a set of operations are sent together and processed atomically), it provides ways to send multiple commands together to reduce the overhead of individual network requests. These include Pipelining, Transactions (MULTI/EXEC), and Lua Scripting.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Using pipelining to batch issue commands",
+        "url": "https://www.alibabacloud.com/help/en/redis/use-cases/use-pipelining-to-batch-issue-commands#:~:text=You%20can%20use%20the%20Redis,network%20latency%20and%20improving%20performance.",
+        "type": "article"
+      }
+    ]
+  },
+  "0Q3AkE8leWAyYsww3-BHX": {
+    "title": "Bitmaps",
+    "description": "In Redis, Bitmaps are a data structure that allows you to manipulate individual bits within a string value. While Redis doesn't have a native \"bitmap\" data type, it uses strings to represent bitmaps. The power of bitmaps comes from their ability to perform operations on binary data at the bit level, making them extremely memory-efficient for certain types of applications, like tracking the presence/absence of elements (such as daily active users, features, etc.).\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Redis Bitmap docs",
+        "url": "https://redis.io/docs/latest/develop/data-types/bitmaps/",
+        "type": "article"
+      },
+      {
+        "title": "Redis bitmap explained",
+        "url": "https://youtu.be/oj8LdJQjhJo?si=jem54LfPbZtrpnEP",
+        "type": "video"
+      }
+    ]
+  },
+  "B-YUFhPQNdr1KZNupmR5N": {
+    "title": "SETBIT",
+    "description": "",
+    "links": []
+  },
+  "0HFLJfcrcSnAVTecG3P8W": {
+    "title": "GETBIT",
+    "description": "",
+    "links": []
+  },
+  "jpcyXSSib7q4WBPmpgnXA": {
+    "title": "BITCOUNT",
+    "description": "The BITCOUNT command in Redis is used to count the number of bits set to 1 (i.e., the number of binary 1s) in the value stored at a specific key. Since Redis allows string values to be stored as binary data, the BITCOUNT command becomes useful for operations involving bits, like efficiently tracking and counting bits in binary-encoded data.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "BITCOUNT - Docs",
+        "url": "https://redis.io/docs/latest/commands/bitcount/",
+        "type": "article"
+      },
+      {
+        "title": "BITCOUNT",
+        "url": "https://upstash.com/docs/redis/sdks/ts/commands/bitmap/bitcount",
+        "type": "article"
+      }
+    ]
+  },
+  "tkrxArg_oYH0aQfM8NkD2": {
+    "title": "BITOP",
+    "description": "",
+    "links": []
+  },
+  "Df1Eu7CuA-ARYii9JVvnm": {
+    "title": "BITPOS",
+    "description": "",
+    "links": []
+  },
+  "s7PEr-5TAm5EGJm0RSjPJ": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "cszjT3YK8oyhGpqLTQzwX": {
+    "title": "HyperLogLog",
+    "description": "",
+    "links": []
+  },
+  "8a4DmPZrX2xGZ7zdWxS63": {
+    "title": "PFADD",
+    "description": "",
+    "links": []
+  },
+  "JWT30KIJQHVw0MXI5sGR6": {
+    "title": "PFCOUNT",
+    "description": "",
+    "links": []
+  },
+  "s50jr_XOUcxh65-tGCKf5": {
+    "title": "PFMERGE",
+    "description": "",
+    "links": []
+  },
+  "XPeCvikPuu6EJ8UcOLGPh": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "zXs_9n2yEb_eVi0WuOQKH": {
+    "title": "Streams",
+    "description": "",
+    "links": []
+  },
+  "7isWhgrUA6M5IGM2U2tm4": {
+    "title": "XADD",
+    "description": "",
+    "links": []
+  },
+  "4sKiAtX5aIL4NDsQkilNC": {
+    "title": "XREAD",
+    "description": "",
+    "links": []
+  },
+  "CiYFuYE8XudZkR6AW2NQ7": {
+    "title": "XRANGE",
+    "description": "",
+    "links": []
+  },
+  "DQJCMEw13lELcw_AwLfrT": {
+    "title": "XLEN",
+    "description": "",
+    "links": []
+  },
+  "zXlSBfa-Gi9_GhSYEzre3": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "4-z4hDKm86qQatYnmE21R": {
+    "title": "More Commands",
+    "description": "",
+    "links": []
+  },
+  "_NiUdVQ85qnvryI38k_vQ": {
+    "title": "Geospatial Indexes",
+    "description": "",
+    "links": []
+  },
+  "U3N1EgHFs1-YUaB_VrJfw": {
+    "title": "GEOADD",
+    "description": "",
+    "links": []
+  },
+  "OWWDLuGTbdNwME7v2jxVP": {
+    "title": "GEOSEARCH",
+    "description": "",
+    "links": []
+  },
+  "GNMjrLPkpTphneoQ0GoZF": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "FCbdKnkI1ZHGekT6yiGua": {
+    "title": "More Commands",
+    "description": "",
+    "links": []
+  },
+  "9W_jaK1DSEZHRKdPcUM7h": {
+    "title": "Pub/Sub",
+    "description": "",
+    "links": []
+  },
+  "55BCntuWlaQiLPqNtb-2i": {
+    "title": "SUBSCRIBE",
+    "description": "",
+    "links": []
+  },
+  "5gkZzm2F4vu6IxUoJLYbK": {
+    "title": "UNSUBSCRIBE",
+    "description": "",
+    "links": []
+  },
+  "gIPo-2CNqE1BsOaDzmkCU": {
+    "title": "PUBLISH",
+    "description": "",
+    "links": []
+  },
+  "V-d6q-3Sf0dl5v8xiCQwl": {
+    "title": "More Commands",
+    "description": "",
+    "links": []
+  },
+  "MvyE_JUJej0UB9xe8Anfj": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "YHbWlKrQqptUDbaQVy0_A": {
+    "title": "Transactions",
+    "description": "",
+    "links": []
+  },
+  "c-y5Eck8VtSyIf8RAW9p7": {
+    "title": "WATCH",
+    "description": "",
+    "links": []
+  },
+  "Ljy-Mc0EBBX4_vXfYZ5-4": {
+    "title": "EXEC",
+    "description": "",
+    "links": []
+  },
+  "U6hST1MkS16T2CHV3-Ise": {
+    "title": "MULTI",
+    "description": "",
+    "links": []
+  },
+  "msW0Wd2H-6FFNDnjC64t-": {
+    "title": "Optimistic Locking",
+    "description": "",
+    "links": []
+  },
+  "Veb30QrPYNjUn13dtGbUr": {
+    "title": "Lua Scripting",
+    "description": "",
+    "links": []
+  },
+  "rjeq3i9oX8IGyQzo--L3c": {
+    "title": "EVAL",
+    "description": "",
+    "links": []
+  },
+  "3X0x_PcJGWBVPL-LSVAln": {
+    "title": "EVALSHA",
+    "description": "",
+    "links": []
+  },
+  "kF_nGo845XDwLkwcQt008": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "bQaek7f3dAaZfSUhwovm1": {
+    "title": "Persistence Options",
+    "description": "",
+    "links": []
+  },
+  "D3pZdAjwPFMRxX1-iyu5-": {
+    "title": "How RDB Works?",
+    "description": "",
+    "links": []
+  },
+  "_pb2DPrFUUZabKxWsuFUo": {
+    "title": "Configuring Save Interval",
+    "description": "",
+    "links": []
+  },
+  "Z6yJwUkcDX08HoMyf1LwX": {
+    "title": "Usecases / Best Practices",
+    "description": "",
+    "links": []
+  },
+  "PTj6oxvpw8vP295WvAI80": {
+    "title": "How AOF Works?",
+    "description": "",
+    "links": []
+  },
+  "ibaZ34-laQtUyxAsERi7o": {
+    "title": "AOF rewrite & compaction",
+    "description": "Persistence refers to the writing of data to durable storage, such as a solid-state disk (SSD). Redis provides a range of persistence options of which AOF (Append Only File) is one of the options. AOF persistence logs every write operation received by the server. These operations can then be replayed again at server startup, reconstructing the original dataset.The rewrite will create a small optimized version of the current Append Only File.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Persistence in redis",
+        "url": "https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/",
+        "type": "article"
+      },
+      {
+        "title": "Enabling redis persistence",
+        "url": "https://youtu.be/qBKnUeR0p10?si=TPvcFtpFMcTZB-Be",
+        "type": "video"
+      }
+    ]
+  },
+  "9ToKTUqbi-NV5Wcwb21PT": {
+    "title": "Truncation / Corruption",
+    "description": "",
+    "links": []
+  },
+  "VvOQUO22ZF8VvDSqHENNU": {
+    "title": "Usecases",
+    "description": "",
+    "links": []
+  },
+  "vzp7DUpjklzIA0E9WxJQA": {
+    "title": "Usecases / Best Practices",
+    "description": "",
+    "links": []
+  },
+  "80035BzcB-fKCvD_3N8zE": {
+    "title": "No Persistence Option",
+    "description": "",
+    "links": []
+  },
+  "3S-qqOlfr60HR4VvDr4He": {
+    "title": "RDB vs AOF Tradeoffs",
+    "description": "",
+    "links": []
+  },
+  "S5Y26m1oHCQpB-oLCdtac": {
+    "title": "Hybrid Persistence",
+    "description": "",
+    "links": []
+  },
+  "rSD8nJ-uNpHJVe5Hn66h7": {
+    "title": "Replication Basics",
+    "description": "",
+    "links": []
+  },
+  "nci3OB1NE1zJHUPfZCOpT": {
+    "title": "Redis Sentinel",
+    "description": "",
+    "links": []
+  },
+  "AQiCcHS6dBAAAPloxiXub": {
+    "title": "Clustering",
+    "description": "",
+    "links": []
+  },
+  "Qy42paiTUsO8HIwbWTMui": {
+    "title": "Authentication",
+    "description": "Authentication in Redis is a security feature used to restrict access to the server by requiring clients to authenticate themselves with a password before performing any commands. This helps prevent unauthorized users from connecting to your Redis instance and performing operations.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "AUTH",
+        "url": "https://redis.io/docs/latest/commands/auth/",
+        "type": "article"
+      }
+    ]
+  },
+  "wsuKH7YwGDV6GYQbdhA4o": {
+    "title": "Network Security",
+    "description": "",
+    "links": []
+  },
+  "gdiWwTQg6A-BFHdQBmgmH": {
+    "title": "SSL/TLS Encryption",
+    "description": "",
+    "links": []
+  },
+  "q2Jw49QUWCUGIfcEC1bZI": {
+    "title": "INFO",
+    "description": "",
+    "links": []
+  },
+  "jBtEiylcedtaE6E20Uk4V": {
+    "title": "MONITOR",
+    "description": "",
+    "links": []
+  },
+  "XBPwHgIsXupMsyoOFkJZ0": {
+    "title": "RedisInsight",
+    "description": "",
+    "links": []
+  },
+  "y5FPSAi6T-5X9SUfR58_-": {
+    "title": "RedisCommander",
+    "description": "",
+    "links": []
+  },
+  "xF0wQYmtwXYkrzvWg5gOO": {
+    "title": "Memory Management",
+    "description": "",
+    "links": []
+  },
+  "Sd1ENOXSFCz1YqccXjr2A": {
+    "title": "Max Memory Policy",
+    "description": "",
+    "links": []
+  },
+  "yaCWw2KjX58SaPajUAb0d": {
+    "title": "Slow Log Analysis",
+    "description": "",
+    "links": []
+  },
+  "kgHwK4N-sfh6dHjd_D_me": {
+    "title": "redis-benchmark",
+    "description": "",
+    "links": []
+  },
+  "2p5RF4lVYfRvYTo1Ofm-a": {
+    "title": "Monitoring",
+    "description": "",
+    "links": []
+  },
+  "hLIT00Iz7rV56ZBIUhWYn": {
+    "title": "Redis Modules",
+    "description": "",
+    "links": []
+  },
+  "jicsfYw56VrbRUt7M8c85": {
+    "title": "RedisJSON",
+    "description": "",
+    "links": []
+  },
+  "_GdTXcJO8uJlhPdfrmeXG": {
+    "title": "Search",
+    "description": "",
+    "links": []
+  },
+  "RBr8opWSh2TKXC8Fmdg0j": {
+    "title": "RedisTimeSeries",
+    "description": "",
+    "links": []
+  },
+  "GwVL5CvbnHsiWb1hVh7lK": {
+    "title": "RedisBloom",
+    "description": "",
+    "links": []
+  },
+  "giyKPtQ-pziA064P8OQD-": {
+    "title": "redis.conf",
+    "description": "",
+    "links": []
+  },
+  "wXRDsNGFckXV_CSiit5sN": {
+    "title": "Backup and Recovery",
+    "description": "Backing up and recovering Redis data is crucial for ensuring data persistence and reliability. Redis, by default, stores its data in memory for fast access, but it provides mechanisms to persist data to disk to allow for recovery in case of failure or system restarts. The primary methods for backup and recovery in Redis are RDB snapshots and AOF (Append-Only File). These methods can be used individually or in combination, depending on the specific use case.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Backup and recovery",
+        "url": "https://redis.io/redis-enterprise/technology/backup-disaster-recovery/",
+        "type": "article"
+      },
+      {
+        "title": "Backup & Restore Redis Cluster with Stash",
+        "url": "https://youtu.be/Py_Ivv-2dcQ?si=z8gAAmhlpUBce4jY",
+        "type": "video"
+      }
+    ]
+  },
+  "Cb-KazR4PuR86VX5oT0zi": {
+    "title": "Upgrading Redis",
+    "description": "",
+    "links": []
+  },
+  "nUIfTkgm3PlSiqgun1BS7": {
+    "title": "Disaster Recovery",
+    "description": "",
+    "links": []
+  },
+  "8lyXDuZJ-KHl4v2_8Ew1h": {
+    "title": "Redis Enterprise",
+    "description": "",
+    "links": []
+  },
+  "cybF72wlJyJbHLUjitLvn": {
+    "title": "Active-Active geo Distribution",
+    "description": "An Active-Active architecture is a data resiliency architecture that distributes the database information over multiple data centers via independent and geographically distributed clusters and nodes. It is a network of separate processing nodes, each having access to a common replicated database such that all nodes can participate in a common application ensuring local low latency with each region being able to run in isolation.\n\nLearn more from the following resources:",
+    "links": [
+      {
+        "title": "Active-Active geo-distribution",
+        "url": "https://redis.io/active-active/",
+        "type": "article"
+      },
+      {
+        "title": "What is active active geo-distribution",
+        "url": "https://youtu.be/x5iHPPZIlQg?si=ZZCwU-tDCIVDboXc",
+        "type": "video"
+      }
+    ]
+  },
+  "sWOFnbh2EyaHRzquz1UeF": {
+    "title": "Redis on Flash",
+    "description": "",
+    "links": []
+  },
+  "ujs77bV8g8-FOm5hBtZFd": {
+    "title": "Security and Compliance",
+    "description": "",
+    "links": []
+  },
+  "JlLwy69eQ1bPHAOOJNqjo": {
+    "title": "When to consider enterprise?",
+    "description": "",
+    "links": []
+  }
+}

public/roadmap-content/server-side-game-developer.json

@@ -0,0 +1,782 @@
+{
+  "rQArtuVKGVgLn_fw9yO3b": {
+    "title": "Server-Side Development",
+    "description": "The term \"server-side\" refers to operations that are performed by the server in a client-server relationship in a computer network. In games, the server-side is responsible for the logic and rules of the game, data persistence, security, and synchronization of the game state among all connected clients. It essentially handles all processing that isn't done on the client-side. Code run on the server-side can be written in various programming languages, but it's often in PHP, Ruby, Python, .NET, Java, or JavaScript (Node.js). Knowing server-side programming is critical for any game developer to create maintainable, scalable, and secure online games.",
+    "links": []
+  },
+  "mUCidjOsVLMAVDf2jmV5F": {
+    "title": "TCP",
+    "description": "TCP, an acronym for Transmission Control Protocol, is a fundamental protocol in the suite of internet protocols. It is a connection-oriented, reliable, byte stream service that sits at the transport layer of the OSI Model. In simpler terms, TCP enables two hosts to establish a connection and exchange data. During this communication, TCP ensures that data is not lost or received out of order by providing error checking mechanisms and a system for retransmission of lost data. Furthermore, to ensure efficient use of network resources, TCP implements flow control, congestion control and provides a means for hosts to dynamically adjust the throughput of the connection.",
+    "links": []
+  },
+  "XxBl-zO7CF6DpOZ2bMDxJ": {
+    "title": "Checksum",
+    "description": "A **checksum** in TCP (Transmission Control Protocol) is a 16-bit field in the TCP header used to perform error checks on the segments. TCP stack computes the checksum value for the data transmitted and sends it along with the data to the receiving system. The receiving system re-computes the checksum and compares it with the value sent along with the data. If both the computed values match, the data is assumed to be free from transmission errors. However, if the computed values don't match, TCP will detect a possible change in received data, and the receiver will request for the re-transmission of the lost or corrupted data packets. Please note that while the checksum operation helps to ensure data integrity, it is not entirely foolproof as it might not detect all possible errors, particularly those that involve multiple bit changes.",
+    "links": []
+  },
+  "zTCmPUp9j5P1wpGgiboMa": {
+    "title": "Segment Structure",
+    "description": "TCP (Transmission Control Protocol) uses a method called \"segmentation\" to manage data transmission. In this approach, TCP divides a stream of data into smaller parts, known as \"segments\". Each of these segments is then independently sent over the internet. A basic TCP segment consists of a header and the data section. The header contains various fields such as source port, destination port, sequence number, acknowledgment number, data offset, reserved section, control bit, window, checksum, urgent pointer, and options. The rest of the segment is occupied by the data transferred by TCP. Understanding the structure of these segments is crucial for understanding how TCP, and thereby much of the Internet, operates.",
+    "links": []
+  },
+  "5sI3RHaLudq4TfpjoYeOp": {
+    "title": "Connection",
+    "description": "`Connection` in server-side game development refers to the establishment of a link between the game server and the game client (usually the player's device). This connection can either be persistent or non-persistent, depending on the game’s requirements. Persistent connections remain active as long as the user is logged in, facilitating real-time communication between the server and the client. Non-persistent connections, on the other hand, are established and discontinued as needed. This element is crucial in multiplayer games where the server handles the synchronization of data among multiple clients, enabling players to interact with each other in the same virtual environment.",
+    "links": []
+  },
+  "LkGI0VpJ3WkpPHkJhJgWk": {
+    "title": "Resource Usage",
+    "description": "In server-side game development, **resource usage** broadly refers to how a game uses the server's computational power, memory, storage, and networking capabilities. These resources are crucial in assuring overall game performance and responsiveness. When monitoring resource usage, you typically pay attention to CPU usage, memory utilization, storage capacity, network bandwidth, and database performance. Server-side code must be developed and optimized with these resources in mind, as inefficient code can lead to increased resource usage, potentially causing lag, disconnections, or crashes. Key elements like scalable architecture and serverless technologies are primarily employed to efficiently manage and balance resource usage. Tools and automated solutions are commonly utilized to monitor and manage these resources in real-time, allowing developers to identify potential issues and optimize accordingly.",
+    "links": []
+  },
+  "5bJUcx3v4dpdlIsx7bFvK": {
+    "title": "Data Transfer",
+    "description": "Data transfer in server-side game development refers to the movement of data between the server and client or among various components of the server itself. Game data, such as player scores, game states, and updates, are frequently transferred to ensure a consistent and updated gaming environment. Various methods are used for data transfer, including RESTful APIs, websockets, and protocol buffers. The choice of method often depends on factors such as the size and type of data, the target platform, and the specific needs of the game. Remember, efficient and secure data transfer is essential for providing a smooth and engaging gaming experience.",
+    "links": []
+  },
+  "1l5dhQWYPhUSg-cy5pSlK": {
+    "title": "Max Segment Scaling",
+    "description": "`Max Segment Scaling (MSS)` is a TCP feature that defines the maximum amount of data that can be received in a single TCP segment. It is specified during the TCP connection establishment phase. The MSS is calculated as the data link layer Maximum Transmission Unit (MTU) minus the size of the TCP and IP headers. The mechanism helps to avoid fragmentation at the IP layer, ensuring the data packets sent are optimal for the network path taken, preventing potential transmission inefficiencies or packet loss issues.",
+    "links": []
+  },
+  "zvBKjceXRSfEe_3MDCEL5": {
+    "title": "Window Scaling",
+    "description": "Window Scaling is a mechanism in the Transmission Control Protocol (TCP) that provides support for larger receiver window sizes beyond the maximum limit of 65,535 bytes. This TCP feature is essential when dealing with high latency or high bandwidth networks (common in server-side game development), where frames might be significantly delayed or rapidly transmitted. The window size initially specified in the TCP header is augmented via a scale factor (defined during the connection setup), allowing the receiver window size to be as large as 1 gigabyte. However, keep in mind that Window Scaling can only be employed at the connection setup stage; once the connection is established, the scaling factor cannot be changed.",
+    "links": []
+  },
+  "6KAYNPLEFMp6Jha8FLMAU": {
+    "title": "Timestamp",
+    "description": "A `timestamp` in server side game development is essentially a sequence of characters, encoding the date and time at which a certain event occurred. This data is particularly significant when tracking the sequence of certain events, debugging issues, logging, and when performing any sort of data analysis. The timestamp is typically generated by the server and it reflects the server's current date and time. For instance, you might find it in a server log file, indicating when each event occurred, or in a database row, showing when each row was created or last updated. Timestamps are often included in the HTTP headers to let the client know when the resource was last modified.",
+    "links": []
+  },
+  "3OMu3RM-6pMjqY1jAmC2-": {
+    "title": "Out-of-Band Data",
+    "description": "\"Out of band\" data, in the context of server-side game development, refers to data that is transmitted separately from the main data stream. This data is used for managing control information rather than actual game data, for instance, data regarding the status of the server, notifications about issues, or urgent commands. Given its importance, it's often designed to bypass any queueing or buffering systems to be delivered straight to the application, hence its name — it is \"out of band\" compared to the normal data transmissions in the game. Please note, out of band data needs proper handling to prevent potential vulnerabilities including security issues.",
+    "links": []
+  },
+  "SPpOO25b7wpajWDIrKi1u": {
+    "title": "Selective Ack.",
+    "description": "Selective Acknowledgement (SACK) is a mechanism introduced in TCP to improve its efficiency in handling packet loss in the network. When TCP detects packet loss, it normally retransmits all packets sent after the lost packet, regardless of whether they were received successfully or not. SACK, however, allows the receiver to acknowledge non-consecutive packets, effectively informing the sender exactly which packets were received successfully and which weren't. By using this mechanism, TCP can selectively retransmit only those packets that were lost, saving bandwidth and improving overall performance.",
+    "links": []
+  },
+  "1GML0Jsfdb1Fn-0PNryiQ": {
+    "title": "Congestion Control",
+    "description": "",
+    "links": []
+  },
+  "X2KHWgQZDHSVDsTRMUwSj": {
+    "title": "Reliable Transmission",
+    "description": "",
+    "links": []
+  },
+  "lDVD-3i64Mk7-KPJrXmFH": {
+    "title": "Flow Control",
+    "description": "",
+    "links": []
+  },
+  "vFM311xSa5OqNVove2f6j": {
+    "title": "Error Detection",
+    "description": "",
+    "links": []
+  },
+  "w6ysmcsBn9jJ8xMvg7hcD": {
+    "title": "Max Segment Size",
+    "description": "",
+    "links": []
+  },
+  "MwLWDlciJOq_0n5S3GoF-": {
+    "title": "Vulnerability",
+    "description": "`TCP` (Transmission Control Protocol) is an important protocol known for its reliability in delivering data packets, but it also has several vulnerabilities. The most significant weakness is TCP’s susceptibility to a variety of **Denial-of-Service (DoS)** attacks, such as TCP SYN flood attacks, where an attacker sends a succession of SYN requests to a target's system in an attempt to consume server resources to make the system unresponsive. Additionally, sequence prediction can be exploited where an attacker can predict the sequence number of TCP packets to hijack the TCP session. There are also risks of IP spoofing, where an attacker can forge the IP address in the TCP packet header and pretend to be another user in the network. These vulnerabilities may expose sensitive information, disrupt normal functions or allow unauthorized access, especially in the context of a server-side game developer dealing with potentially large volumes of traffic.",
+    "links": []
+  },
+  "TbXJO__4xSnzK1fvvJK86": {
+    "title": "Denial of Service",
+    "description": "Denial of Service (DoS) is a malicious attempt to disrupt the regular functioning of a network, service, or server by overwhelming the network or server with a flood of internet traffic. The most common type of DoS attack involves flooding the target with unnecessary requests in an attempt to overload the system. In a Distributed Denial of Service (DDoS) attack, multiple computers are used to carry out the cyber attack. For servers, these attacks can significantly affect the availability and performance of games, causing a poor experience for the users.",
+    "links": []
+  },
+  "ubRiY3jdh3iS3diN482IU": {
+    "title": "Connection Hijacking",
+    "description": "`Connection hijacking`, also known as session hijacking, is a serious security threat in the realm of server side game development. It refers to the exploitation of a valid computer session, or more precisely, the intrusion of an unauthorized user into a valid connection between two nodes or endpoints. The attacker intercepts the traffic between these two nodes, thereby 'hijacking' the connection. In game development, this could involve intercepting information between a game server and a client's system. Connection hijacking could expose sensitive data, tamper with the data in transit, or even redirect clients to rogue servers. Hence, implementing necessary security protocols to mitigate such vulnerability is crucial.",
+    "links": []
+  },
+  "ZLTfpRZ0rF-mtd7Z0R2WF": {
+    "title": "Veto",
+    "description": "`Veto` is often used in multiplayer games to prevent or allow certain actions during the game. For instance, players can issue commands to block specific actions from their opponents. As a server-side game developer, you must ensure security measures are in place to validate the authenticity of these commands to safeguard against potential vulnerability. A veto vulnerability can occur when malicious players manipulate veto commands to their advantage or disrupt the game, which can lead to an unfair gaming environment or even crash the server. Therefore, your code should always verify who is sending veto commands and check the validity of these commands.",
+    "links": []
+  },
+  "IMyHwnXxJK6oFxzOMLxjS": {
+    "title": "UDP",
+    "description": "`UDP`, or User Datagram Protocol, is a communications protocol that sends data over the internet. Unlike TCP (Transmission Control Protocol), it's a connectionless protocol that doesn't ensure data packet delivery. It transmits datagrams – an independent, discrete packet of data – without first establishing a proper handshake between the sender and the receiver. The sender doesn't wait for an acknowledgment after sending a datagram, and the receiver doesn't send any acknowledgment upon receiving a datagram. This makes UDP faster but less reliable than TCP. UDP is used for time-sensitive transmissions where dropped packets are acceptable, such as in live video streaming, voice over IP (VoIP), and online multiplayer gaming.",
+    "links": []
+  },
+  "Vh81GnOUOZvDOlOyI5PwT": {
+    "title": "Reliability",
+    "description": "Reliability refers to how consistently a data packet can be transferred from one system to another over a network. In terms of the User Datagram Protocol (UDP), it has a lack of reliability built into it. This means UDP does not guarantee that your data will reach its destination, it merely sends the packets without any acknowledgement of receipt. Unlike its counterpart, Transmission Control Protocol (TCP), which implements error-checking mechanisms to ensure data integrity and delivery. In summary, if you require high reliability in your server side game development, protocols other than UDP might need to be considered.",
+    "links": []
+  },
+  "wD_HWc9YxPhlkilt585pg": {
+    "title": "Datagram",
+    "description": "A **Datagram** is the basic unit of data transfer in network communication using protocols such as User Datagram Protocol (UDP). Each datagram operates independently of each other, meaning they may be received in a different order than they were sent, or they might not be received at all. Therefore, unlike TCP (Transmission Control Protocol), UDP does not guarantee that datagrams are delivered in the same order that they were sent, or even at all - hence known as connectionless protocol. However, it is faster and more efficient for applications that do not require delivery guarantees, such as voice over IP, live video broadcasts, and other real-time applications. Each datagram contains information about the sender, the intended recipient, and the data that it is intended to communicate along with its size and other specifications.",
+    "links": []
+  },
+  "jsNsyrGzegVnjIF2l52vI": {
+    "title": "Congestion Control",
+    "description": "`Congestion Control` is a critical feature of TCP, but not inherently a part of UDP. The primary purpose of congestion control is to prevent too much data from being sent into the network such that it can't handle the traffic, leading to packet loss. TCP's congestion control mechanism adjusts the data send rate based on the perceived network congestion. UDP does not provide congestion control by itself. However, this does not mean congestion control can't be implemented if you're using UDP. Developers can implement a custom congestion control mechanism over UDP, but it requires substantial understanding and careful management to achieve this without creating network or server performance issues.",
+    "links": []
+  },
+  "tBOvBpDi3SOKZjAmkxdM0": {
+    "title": "Checksum",
+    "description": "The `checksum` is an important element in UDP that ensures the integrity and validation of the data being transmitted. It computes the total sum of all the bytes in a packet and incorporates it as an additional `checksum` field in the UDP header. When the packet arrives at its destination, this process is repeated and compared with the included `checksum`. If a match is observed, the packet is deemed valid. If not, it signifies that an error occurred during transmission possibly due to noise or any third-party interference. In such a case, the packet is simply dropped, as UDP does not initiate any retransmission or error correction procedure. This is why a perfect output cannot be guaranteed with UDP, nor can it determine whether all the recipients are receiving the packets properly.",
+    "links": []
+  },
+  "CCxVnrGDKa1EROXgF_OAm": {
+    "title": "Packet Structure",
+    "description": "UDP or User Datagram Protocol is designed to send messages known as datagrams over the network. The packet structure of UDP is relatively simple compared to other protocol types. Each UDP header consists of 4 fields, each of 2 bytes. These 4 fields are namely: Source Port, Destination Port, Length, and Checksum. The `Source Port` is for tracking responses and `Destination Port` is for delivering the datagram on the receiving end. The `Length` specifies the entire datagram size including the header and data while the `Checksum` is used to verify the integrity of the data and header.",
+    "links": []
+  },
+  "RfTcTUjaXyp49FnUf44MK": {
+    "title": "TCP vs UDP",
+    "description": "TCP, or Transmission Control Protocol, is a connection-oriented protocol that guarantees delivery of packets to the destination router. It includes error-checking and ensures packets are delivered in the correct order. On the other hand, UDP, or User Datagram Protocol, is a connectionless protocol which doesn't guarantee delivery or ensure correct sequencing of packets. As a result, UDP is considered faster and more efficient for some applications like video streaming or online gaming where speed matters more than accuracy. So, choosing between TCP and UDP really boils down to the specific requirements and priorities of the situation - it's a trade-off between speed and reliability.",
+    "links": []
+  },
+  "MoyBGT9bscUe8vMN4J0bG": {
+    "title": "Reliable vs Unreliable",
+    "description": "In the context of network communication, the terms \"reliable\" and \"unreliable\" refer to whether or not data sent across the network is guaranteed to reach its destination. Reliable protocols, such as TCP, ensure that data is delivered from sender to receiver without loss. They do this by establishing a connection, dividing data into packets, sending them one by one, and waiting for acknowledgment of receipt from the receiver. Each sent packet is numbered so if any packet doesn't reach the receiver, it will be identified by the missing sequence number and resent. In this way, reliable protocols ensure data integrity and order.\n\nOn the other hand, unreliable protocols, such as UDP, do not guarantee delivery. They simply transmit data without any checks to ensure it has been received. If a packet is dropped for any reason, it is not resent. These protocols do not establish a connection nor check for successful data transfer. This leads to potential data loss, but it provides a faster and more efficient transmission process which can be desirable in certain situations.",
+    "links": []
+  },
+  "WMdCDmFsytsF2AWQXfzC8": {
+    "title": "Ordered vs Unordered",
+    "description": "In the context of TCP vs UDP, \"ordered\" and \"not ordered\" refers to the order in which packets are received. In TCP (Transmission Control Protocol), packets are ordered. This means that the packets of data are sent and received in the same order. For example, if packet 1, packet 2, and packet 3 are sent in that order, they will be delivered and read in that exact order whether, packet 2 takes longer to send or not. On the other hand, UDP (User Datagram Protocol) is not ordered. The packets of data are independent of each other. So, if packet 1, packet 2, and packet 3 are sent in that order, they could be received in a different order such as packet 2, packet 1, then packet 3. This happens because UDP doesn't re-order packets as TCP does.",
+    "links": []
+  },
+  "OYXKtl4A-vaK6yGO6hS6n": {
+    "title": "Heavy vs Lightweight",
+    "description": "TCP (Transmission Control Protocol) is often described as a \"heavyweight\" protocol because it provides numerous features such as error-checking, guaranteed delivery, and order-of-arrival of data packets, which makes it more complex to implement in the server. This complexity results in additional server load, making it heavier in terms of processing resources and system requirements.\n\nOn the other hand, UDP (User Datagram Protocol) is known as a \"lightweight\" protocol. It is simpler and faster because it does not offer the same extensive features as TCP. UDP does not guarantee delivery, does not require initial handshake establishment between communicating systems, and does not put data packets in order, thereby reducing the computation and rendering it lightweight.",
+    "links": []
+  },
+  "JE3uZ5U6oe6dVzsmglTl2": {
+    "title": "Packet vs Datagram",
+    "description": "**Packet** and **Datagram** are terms used in data communication.\n\nA **Packet** is the most general term that just refers to the encapsulated data passed across networks. It is the generic term used to describe unit of data at all levels of the protocol stack. Packets include not just the data, but also headers and footers with control information, such as source and destination addresses, error checking codes, and sequencing information.\n\nOn the other hand, a **Datagram** is a specific type of data packet. It is an independent, self-contained message sent over the network whose arrival, arrival time, and content are not guaranteed. This term is particularly associated with the UDP (User Datagram Protocol), where each transmission unit is called a datagram.\n\nThe difference between packets and datagrams depends largely on the protocol being used to transmit the data. TCP (Transmission Control Protocol) data is typically referred to as a packet, whereas with UDP it is a datagram.",
+    "links": []
+  },
+  "pJw8fN1dt3BABtZVz7wGE": {
+    "title": "Streaming vs Broadcast",
+    "description": "In the context of network protocol, streaming and broadcasting are two methods for transmitting data packets. Streaming, often performed over TCP, entails sending data from one source to a single specific destination. This method is comparable to a one-to-one phone call. The streaming process is characterized by steady data transmission directly to a single receiver who has initiated a connection. On the contrary, broadcasting refers to the transmittal of data packets from one source to all possible destinations in the network. Similar to a public announcement over a loudspeaker, the data is sent to all receptive entities. Broadcasting primarily utilizes the UDP protocol and does not require a direct connection or acknowledgement of receipt from the recipients.",
+    "links": []
+  },
+  "tg94V7K0mgYhpkUMp_Scv": {
+    "title": "IP",
+    "description": "**Internet Protocol (IP)** is the primary method used to send and receive messages on the internet. It's a set of rules that dictate how data should be delivered over the internet. An IP address is a unique string of numbers separated by periods that identifies each device using the Internet Protocol to communicate over a network. There are two types: IPv4 and IPv6. IPv4, the most common, consists of four groups of numbers, each ranging from 0 to 255. For example, \"192.168.0.1\". On the other hand, IPv6, the next-generation protocol, provides about 340 undecillion addresses, ensuring the ability to provide unique IPs for every device on the planet. For instance, \"2001:0db8:85a3:0000:0000:8a2e:0370:7334\". Each IP address can be static (permanent) or dynamic (changeable), depending on your network configurations.",
+    "links": []
+  },
+  "5kF1fqr-mn5-15e3aMa9k": {
+    "title": "Capability",
+    "description": "In server-side game development, `capability` basically refers to the potential of the server in terms of supporting the game mechanics, the players, the network traffic, and other elements that allow the game to function effectively. Hosting servers condition the player's game interface and user experience, incorporating the aspects of speed, smooth game flow, glitch prevention, and high-performance gameplay. Certain servers have higher capabilities, supporting complex games with vast virtual environments, numerous players, and extensive data traffic. Their capacity extends to facilitating updates and patches immediately. On the other hand, servers with lower capabilities might only cater to simpler games. Ultimately, the `capability` of an IP server is a key factor in developing and maintaining a successful online, multiplayer, or large-scale game.",
+    "links": []
+  },
+  "2jDV-ovvrkBbTTLk5VbR9": {
+    "title": "Reliability",
+    "description": "The **Reliability** in terms of IP (Internet Protocol) generally refers to the dependability and consistency of the network connections. It's essentially about how reliable the data transfer is over the network. IP itself is an unreliable protocol, meaning it doesn't guarantee the delivery of data packets. This is where protocols like TCP (Transmission Control Protocol) come in. TCP adds a layer of reliability to IP by ensuring the delivery of the data packets, ordering them correctly and error-checking. This ensures that game data synchronizes correctly across the server and clients without any loss, providing consistency and a smooth gameplay experience. However, the full guarantees of TCP come with some additional overhead; therefore, some games might prefer to use unreliable protocols when high performance is more critical than absolute reliability.",
+    "links": []
+  },
+  "OzY-LPcfj1sBm_0F0WbIJ": {
+    "title": "Link Capacity",
+    "description": "Link capacity, also known as bandwidth, refers to the maximum amount of data that can be transmitted over a network link within a given period of time. It is usually measured in bits per second (bps), kilobits per second (Kbps), megabits per second (Mbps), gigabits per second (Gbps), or terabits per second (Tbps). The link capacity is a critical factor in determining the throughput and latency of a server, impacting the overall performance and efficiency of the network communication. Please note that link capacity can be affected by various factors such as the quality of the transmission medium, the distance between the source and destination, and the network congestion.",
+    "links": []
+  },
+  "YPvm8XD_FaFYCQ-b7-KsH": {
+    "title": "Function",
+    "description": "In server-side game development, functions are a fundamental building block of programming. These are reusable pieces of code designed to perform a particular task. Developers create functions to streamline code, improve readability, and enhance the efficiency of their program. Functions can take parameters as input and return a result. The syntax for declaring a function varies from one programming language to another. However, the basic structure remains the same. It usually starts with a function keyword, followed by the function name and parentheses `()`. Inside these parentheses, we can pass parameters. These parameters are then utilized within the function's body enclosed within curly brackets `{}`. The outputs are typically returned using a return statement. Remember, each function should ideally perform one task, and the function name should accurately represent its purpose to make the code self-explanatory.",
+    "links": []
+  },
+  "jnQAzUUnwpJgoRuRIFtSe": {
+    "title": "Datagram Construction",
+    "description": "Datagram construction is a fundamental process in server-side game development, especially when dealing with UDP (User Datagram Protocol). In this context, a datagram is a basic transfer unit associated with a packet-switched network, which typically encompasses a header and payload data. The process of datagram construction involves encapsulating the specific game data (such as player position, game state, etc.) in the datagram payload and setting appropriate values in the datagram header such as Source and Destination IP addresses, Checksum and other protocol-specific values. Constructing and parsing datagrams correctly is crucial for ensuring reliable and efficient communication between the game server and clients.",
+    "links": []
+  },
+  "3ZcJNDCHw2pFzewmoB-03": {
+    "title": "IP Addressing",
+    "description": "IP (Internet Protocol) addressing is a fundamental aspect of networking, at the core of interaction between systems in a network. Each device connected to a network must have a unique address, known as an IP address, to communicate with other devices. In version 4 of the IP protocol (IPv4), these addresses are usually represented as four numbers, each ranging from 0 to 255, separated by periods (e.g., 192.168.1.1). The newer standard, IPv6, introduced to deal with the shortage of available IPv4 addresses, employs a more complex notation using hexadecimal numbers and colons. However, the purpose remains the same: to uniquely identify each device on a network. IP addresses can be either static (permanently assigned to a device) or dynamic (assigned temporarily from a pool of addresses).",
+    "links": []
+  },
+  "bYb7nA-Vn9e6VtdbUT3tq": {
+    "title": "Routing",
+    "description": "In server-side game development, **routing** refers to the specification of how an application responds to a client request to a particular endpoint, which is a URI (or path) and a specific HTTP request method (GET, POST, etc.). Each route can have one or more handler functions, which are executed when the route is matched. These handler functions, often coming into play within complex multiplayer game scenarios, handle the logic needed for the route, including data transmission, game state updates, etc. The use of properly configured routes ensures the correct data is sent where it is needed, supporting seamless gameplay interactions.",
+    "links": []
+  },
+  "r2OeI7YC1BLLfctC8q69W": {
+    "title": "Transactions",
+    "description": "In server-side game development, **transactions** are critical elements that facilitate the exchange or interaction between different processes and data streams. These are usually carried out via a database or a server and are atomically treated as a single unit of work, ensuring data consistency and integrity. Transactions follow a specific pattern known as ACID (Atomicity, Consistency, Isolation, Durability) which makes sure that all intended operations within a transaction are successfully performed or none of them are, preventing disruptions in the event of an error or failure. It also ensures that concurrent execution of transactions results in a system state that would be achieved if transactions were executed sequentially. It's important for a server-side game developer to understand how to manage and control transactions to maintain the robustness of the game's backend system.",
+    "links": []
+  },
+  "JI_wUdT2hjsrvbIhLvHcT": {
+    "title": "ARP",
+    "description": "**ARP** or **Address Resolution Protocol** is a protocol used to map an IP address to a physical address on the network, such as a MAC address. A device uses ARP when it needs to forward a packet to another device on the same network but only has the IP address. ARP broadcasts a request packet to all devices on the local network to find who owns the IP address. The device with the matching IP address replies with its MAC address. ARP maintains a cache of previously resolved addresses to minimize traffic. It is an essential protocol in network communication, but it also exposes certain security vulnerabilities like ARP spoofing.",
+    "links": []
+  },
+  "yNytLrQAMKBw4t73YRL3J": {
+    "title": "DNS",
+    "description": "**Domain Name System (DNS)** is an internet service that translates domain names into IP addresses. The internet uses IP addresses to locate and connect different computers, but these numerical addresses can be difficult to remember or use practically. Therefore, DNS allows users to type in a domain name, such as [www.example.com](http://www.example.com), and it translates this name into the equivalent IP address, such as 192.0.2.1. It is used every time you visit a website, send an email, or connect to any service on the internet. DNS serves as the internet's phone book, ensuring that every domain name corresponds to the correct IP address.",
+    "links": []
+  },
+  "aTHJh-xw8soCxC1bIDdXm": {
+    "title": "DHCP",
+    "description": "DHCP, or Dynamic Host Configuration Protocol, is an internet protocol that enables automatic assignment of IP addresses to devices on a network. Its key role in network systems is to eliminate the manual task of assigning IP addresses in a large network. DHCP can be implemented in small, medium, or large networks encompassing hundreds of computers or even more. It involves a DHCP server, which is responsible for allocating IP addresses and controlling the process. This server maintains a pool of IP addresses, which it assigns to devices as they connect to the network. DHCP also handles release and renewal of these IP addresses as devices leave and rejoin the network.",
+    "links": []
+  },
+  "NH2eQ1_nij1icTgoO027b": {
+    "title": "Category",
+    "description": "The Internet Protocol Addresses (IP Addresses) are categorized into five different classes, namely, Class A, Class B, Class C, Class D, and Class E.\n\n**Class A** IP address is designed for large networks and ranges from 0.0.0.0 to 127.255.255.255.\n\n**Class B** IP addresses are allocated to medium-sized and large-sized networks and ranges from 128.0.0.0 to 191.255.255.255.\n\n**Class C** IP addresses are utilized for small-sized networks and ranges from 192.0.0.0 to 223.255.255.255.\n\n**Class D** IP address is designed for multicast groups and ranges from 224.0.0.0 to 239.255.255.255.\n\nLastly, **Class E** IP address ranges from 240.0.0.0 to 255.255.255.254 and is preserved for research and development purposes.",
+    "links": []
+  },
+  "pHVB0K8Vtk3ToD6n_f1wv": {
+    "title": "IPv4",
+    "description": "`IPv4`, or Internet Protocol Version 4, is the fourth version of IP (Internet Protocol). It's a foundational protocol that routes most of the Internet traffic today, even with the growing reach of IPv6. `IPv4` is responsible for identifying devices on a network through an addressing system. The `IPv4` uses a 32-bit address schema allowing for a total of just over 4 billion addresses. Most importantly, `IPv4` determines how data is sent and received over network devices. This standard of `IPv4` helps to route data between networks and has been foundational in the creation of the modern Internet.",
+    "links": []
+  },
+  "TqBlAMfhARhlJed6xD7eg": {
+    "title": "IPv6",
+    "description": "IPv6, which stands for Internet Protocol version 6, is the most recent version of the Internet Protocol (IP), formulated to rectify the impending issue of IPv4 address exhaustion. Unlike IPv4, which uses 32-bit address, IPv6 employs a 128-bit address, enabling a massive number of unique IP addresses to exist. This augments the capacity of the internet to accommodate an array of networks and devices, serving as a sustainable solution for an ever-expanding digital world. IPv6 also provides enhanced functionalities including simplified header format, improved support for extensions and options, built-in security using IPsec, and better support for QoS (Quality of Service). In server side game development, IPv6 ensures smooth and lag-free game experiences to players by enabling direct peer-to-peer connections.",
+    "links": []
+  },
+  "qkO0s9zR0sAnjTRWcrLQY": {
+    "title": "Security",
+    "description": "In server-side game development, the aspect of IP (Internet Protocol) security is of paramount importance. This primarily involves ensuring the safety of online gaming interactions, protection of sensitive user data being transmitted, and thwarting possible cyber-attacks or threats. This might include mitigation strategies against DDoS (Distributed Denial of Service) attacks, which are common in multiplayer gaming environments, IP spoofing, and session hijacking. Security measures often involve developing secure server architectures, encryption of data in transit and at rest, validation and sanitization of user input, and implementing comprehensive security policies and procedures. Regular risk assessment and vulnerability scanning are also crucial for identifying and addressing potential security loopholes. Therefore, for any game developer, understanding IP security protocols and integrating them into game development processes is essential to provide users with trustworthy gaming environments.",
+    "links": []
+  },
+  "FX8ASd-QzTUFDHzBB93WK": {
+    "title": "TLS",
+    "description": "",
+    "links": []
+  },
+  "6ilqzjvI4J1pUCmTJ33PA": {
+    "title": "Programming Languages",
+    "description": "Programming languages are an essential part of game development. They create the logic and rules for how your game operates. There are various types of programming languages that a server side game developer can use, such as C++, Python, Ruby, etc. These languages have different syntax and structures, as well as varying degrees of complexity. The complexity and capabilities can affect the game's performance, security, and even its potential compatibility with other platforms. Your choice of language often depends greatly on the specific needs of the project and your personal expertise. Picking up a new language can be time-consuming, so it's important to choose wisely. Markdown is another language that's popular for documentation due to its simplicity and readability, but it isn't typically used to code server-side game elements.",
+    "links": []
+  },
+  "E4H3hniIW6hKpH3Qr--N5": {
+    "title": "C/C++",
+    "description": "\"C\" and \"C++\", often written as \"C/CPP\", are two significantly prominent and similar programming languages widely used in server-side game development. \"C\" is a procedural language, which means that it follows a step-by-step procedure to solve a problem, while \"C++\" is both a procedural and object-oriented programming (OOP) language. This dual nature of \"C++\" allows it to handle more complex interrelated data and functions efficiently, which is a beneficial feature in game development. Moreover, \"C++\" is an extension of \"C\", meaning that any legal \"C\" program is also a valid \"C++\" program. Both languages offer a high degree of control over system resources and memory, making them an excellent choice for building fast and efficient server-side applications, such as multiplayer game servers.",
+    "links": []
+  },
+  "DuyUc9a-47Uz03yr4aeyg": {
+    "title": "C#",
+    "description": "C Sharp, usually written as C#, is a powerful, object-oriented programming language developed by Microsoft in the early 2000s. C# was designed to be a part of the .NET ecosystem and has its syntax foundations based on C and C++. Over time, C# has evolved to include several modern programming features like generics, asynchronous methods, and support for LINQ queries. Thanks to the .NET Core's cross-platform support, C# can now be used to write applications that run on Windows, Linux, and macOS. While it's widely used to create Windows desktop applications and games, it's also popular for developing web applications, server-side components, and even mobile applications via Xamarin.",
+    "links": []
+  },
+  "LG8JPL1po-gEs1V5JyC8F": {
+    "title": "Java",
+    "description": "Java is an object-oriented programming language that is class-based and designed to have as few implementation dependencies as possible. It was originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems' Java platform. The language's syntax has much in common with C and C++, but its object model is simpler and has less low-level facilities. Java applications are typically compiled to bytecode that can run on any Java Virtual Machine (JVM), making Java applications highly portable. Java is a general-purpose programming language and is used widely for server-side applications, particularly in high-performance environments where speed and scalability are critical.",
+    "links": []
+  },
+  "QGtGx5LBEWa1DD3Y7ztUy": {
+    "title": "Erlang",
+    "description": "Erlang is a functional, general-purpose concurrent programming language that supports distributed computation. It originated in the late 1980s, born from Ericson Inc., with the aim to improve the development of telephony applications. Erlang has built-in support for concurrency, distribution and fault tolerance which make it a popular choice for developing large scale, real-time systems. The language is mostly used in sectors where systems must continue to work despite errors, such as banking, eCommerce, computer telephony and instant messaging. Over the years, Erlang has been employed in blockchain development, internet of things (IoT) and online gaming programming where robust server-side development is required.",
+    "links": []
+  },
+  "ufufnULqsglE5VhEIAdSI": {
+    "title": "JavaScript",
+    "description": "JavaScript (often abbreviated as JS) is a high-level, interpreted programming language that conforms to the ECMAScript specification. It plays a key role in web development as it is one of the three core languages of the World Wide Web, along with HTML and CSS. In server-side game development, JavaScript can be utilized through runtime environments such as Node.js. Over the years, JavaScript has evolved to incorporate additional features, such as support for object-oriented and functional programming styles. It is dynamically-typed, and supports event-driven programming, which is especially handy in game development for handling user inputs and system events. Despite its name, JavaScript is not related to Java.",
+    "links": []
+  },
+  "d5iQYn97vuoxJnCFGPdOa": {
+    "title": "Go",
+    "description": "",
+    "links": []
+  },
+  "HvpuFTCknHPhnFkhmhRc4": {
+    "title": "Socket Programming",
+    "description": "Socket programming is a method of communication between two computers using a network protocol, typically TCP/IP. In server-side game development, socket programming is used to facilitate real-time, bi-directional communication between the server and client(s). The server opens a socket that waits for incoming connection requests from the client side. Once a connection is established, the server and client can exchange data until the connection is closed. This facilitates live multiplayer gaming experiences, allowing users on different computers to interact within the same game environment.`socket programming` in Python, for example, includes modules for creating both the server side (`socketserver`) and client side (`socket`) of the conversation.",
+    "links": []
+  },
+  "H21PanCggDfQt34-JzgfO": {
+    "title": "Byte Manipulation",
+    "description": "`Byte manipulation`, in the context of socket programming, often refers to the ability to directly interact and manage bytes of data. This could involve creating, modifying, or reading individual bytes or groups of bytes. Common operations include shifting (moving bytes to the left or right), masking (using a binary AND operation to make certain bits 0), and bitwise operations (working with the individual bits within a byte). Byte manipulation commonly takes place in server side game development when dealing with network data or working with specific binary protocols. The ability to accurately manipulate bytes is an essential skill when handling and optimizing the transfer of data between a server and a client.",
+    "links": []
+  },
+  "SBA7pa9o0AM0ZEBepd7UM": {
+    "title": "Address Conversion",
+    "description": "In socket programming, address conversion functions are important for handling internet addresses. Functions like `inet_pton()` (presentation to network) and `inet_ntop()` (network to presentation) are frequently used. `inet_pton()` function converts an IP address in human-friendly format (IPv4 addresses in dotted-decimal notation or IPv6 addresses in hexadecimal notation) to its equivalent binary form. Conversely, `inet_ntop()` function does the reverse, i.e., it converts an IP address in binary form to human-friendly format. These functions are important tools when dealing with IP addresses in lower-level network programming.",
+    "links": []
+  },
+  "OAyMj6uLSv1yJ87YAjyZu": {
+    "title": "Descriptor",
+    "description": "In the context of socket programming, a **descriptor** is simply an identifier for a resource. With the use of these descriptors, socket applications can interact with system resources such as network connections, files, or data streams. For instance, in C-based languages such as C++, socket programming frequently makes use of file descriptors. These are integer values used by the operating system to identify open files and network sockets. It is crucial for a server-side game developer to understand and make efficient use of descriptors to control and manage all the network protocols, ensuring seamless game experiences.",
+    "links": []
+  },
+  "a2pcxVTGdAPw8aLvdr19M": {
+    "title": "API",
+    "description": "API (Application Programming Interface) is a set of rules and protocols implemented for building and integrating software applications. APIs enable two different software applications to communicate and work together. They work as a bridge connecting two software systems, enabling them to exchange information and execute functions. In the context of server-side game development and socket programming, APIs may be used to handle connection establishment, data transmission, and other necessary network communication operations. APIs can be customized or built based on standard protocols such as HTTP for web services, or TCP/UDP for lower-level socket communications.",
+    "links": []
+  },
+  "U_tZFM80W3xJx8jj4skCr": {
+    "title": "BSD Socket",
+    "description": "The BSD sockets API is an application programming interface (API) for network communication originally developed as part of the Berkeley Software Distribution (BSD). This API provides a set of functions for creating and manipulating network sockets in operating systems. It has been widely adopted in a variety of platforms due to its simplicity and ease of use for networking tasks. The BSD socket API supports various network protocols and is extensible to support new protocols. It allows low-level access to network services, with the facilities to manage connections, send and receive data, and handle multiple connections concurrently. The API supports both connection-oriented (TCP) and connectionless (UDP) network protocols.",
+    "links": []
+  },
+  "GfTXffisLyQgp66zcQ7Py": {
+    "title": "Winsock",
+    "description": "`Winsock` is an acronym for Windows Sockets API, a technical specification that defines how networking software should interact with TCP/IP network protocols, such as TCP, UDP, and ICMP, on a Windows Operating System. Essentially, Winsock provides an interface for developers to use when they need to write network applications. This API provides functionalities to create a socket, bind it to a specific address, listen to incoming connections, send and receive data, and finally, close the connection. Winsock also aids in handling network errors and exceptions. For developing multiplayer server-side games, it is useful in managing client-server communications, multiplayer logic, and real-time updates. Note that in the gaming context, the Winsock library is typically used for real-time, high-performance applications due to its low-level access to the TCP/IP stack.",
+    "links": []
+  },
+  "TS6dz61rUSxm-SqmK6JKe": {
+    "title": "Serialization",
+    "description": "Serialization in server-side game development is the process of transforming data objects or structures into a format that can be stored, transmitted, and reconstructed later. It's significant because it enables you to save the state of a game, pass it between servers, or send it to clients. The two main types of serialization are binary and XML/JSON. Binary serialization turns your objects into a very compact binary format. XML/JSON serialization turns your objects into a textual format, which is less efficient but more human-readable and easier to debug. Depending on your specific needs, you may choose one over the other. Note also that each of these methods has its own exacerbations in terms of compatibility, performance, and security implications.",
+    "links": []
+  },
+  "y0ZJQQfi8Qx6sB4WnZlP5": {
+    "title": "JSON",
+    "description": "**JSON (JavaScript Object Notation)** is a lightweight data-interchange format that is easy to read and write for humans, also easy to parse and generate for machines. JSON is a text format that is completely language independent but uses conventions familiar to programmers of the C family of languages, including C, C++, C#, Java, JavaScript, Perl, and Python. In JSON, data is organized in name-value pairs and array data types. It is commonly used for transmitting data in server to web applications and vice versa.",
+    "links": []
+  },
+  "v43K6srds7m5SQFqNaY0T": {
+    "title": "XML",
+    "description": "XML, or Extensible Markup Language, is a language designed to store and transport data without being dependent on a particular software or hardware. Unlike HTML which displays data and focuses on how data looks, XML works as a tool to transfer data and emphasizes on what the data is. XML data is known as self-describing or self-defining, as it has the ability to define and describe the structure and data types itself. It uses tags just like HTML, but the tags in XML are not predefined; it allows the author to define his/her own tags and document structure. XML also supports Unicode, allowing almost any information in any human language to be communicated. It adheres to a strict syntax and is both human-readable and machine-readable, making it a widely used standard in web and server-side development.",
+    "links": []
+  },
+  "uHcUSVLz_2-Usk6ckSvwr": {
+    "title": "YAML",
+    "description": "YAML, which stands for \"YAML Ain't Markup Language,\" is a human-readable data serialization standard that can be used in conjunction with all programming languages. It is often used to write configuration files and in applications where data is being stored or transmitted. YAML supports advanced features like referencing, merging, arrays and dictionaries. Also, it is flexible and supports various data structures like scalars, sequences, associative arrays. Though it might seem similar to JSON and XML, it focuses on data serialization rather than marking up documents, and ensures readability for humans. It uses a whitespace indentation to denote structure, which can simplify file format complexities.",
+    "links": []
+  },
+  "l8iEC3g0ICSfmIE1MxcUl": {
+    "title": "TOML",
+    "description": "`TOML`, which stands for Tom's Obvious, Minimal Language, is a configuration file format that is easy to read due to its straightforward and simple syntax. The language is designed to be unambiguous and lean, intending to make it easy for a machine to parse. It supports basic data types, such as Integer, String, Boolean, and Float, Date-Time, Array, and Table. Unlike other similar file formats, `TOML` provides a more structured hierarchy. You can use `TOML` for configuration, serialization, and other similar tasks in game development.",
+    "links": []
+  },
+  "w2zbab_6Gxw6AWS0N759U": {
+    "title": "Protobuf",
+    "description": "`Protobuf`, or Protocol Buffers, is a method developed by Google for serializing structured data. It's both language-neutral and platform-neutral. Google designed it to be smaller and faster than XML. You design your data structures in `.proto` files, then use the Protobuf compiler `protoc` to generate data access classes in your chosen language. Google provides support for several languages including: Java, C++, Python, Objective-C, and C#. Community developed support for even more languages is also available. This gives `protobuf` a great deal of versatility, making it a popular choice for data storage and communication between services.",
+    "links": []
+  },
+  "3QSLUMKD0G08N3MIb1cG7": {
+    "title": "Multithreading",
+    "description": "Multithreading, a specialized form of multitasking, is the ability of a central processing unit (CPU) to manage multiple executions of instructions concurrently. This essentially means that multiple threads or mini-processes are executing independently yet sharing the resources of a single CPU. In programming, threads are a way to improve the application responsiveness and perform multiple operations simultaneously without requiring multiple CPUs or computers. Threads within a process share the same data space with the main thread and can, therefore, communicate more quickly with each other than if they were separate processes. Developers often use multithreading in server-side game development to manage complex operations with high efficiency.",
+    "links": []
+  },
+  "idmrgKgVWVLZYANbXiZnS": {
+    "title": "Synchronization",
+    "description": "In the context of multithreading, **synchronization** is a mechanism which ensures that two or more concurrent threads don't simultaneously execute some particular program segment known as a critical section. Concurrent accesses to shared resource can lead to race conditions. Two or more operating systems' threads can access shared data simultaneously. With synchronization, you can ensure that only one thread can access the shared resource at a time, hence avoiding any data inconsistency. Different synchronization techniques such as locks, semaphores, condition variables, monitors and signaling are used to deal with synchronization situations, each with its own pros and cons.",
+    "links": []
+  },
+  "6k25amPkU9lnZ7FMNn_T6": {
+    "title": "Barrier",
+    "description": "`Barrier` in server-side game development refers to a type of synchronization method that can help manage multiple threads in a game's code. When a barrier point is set, all threads that reach this point are prevented from progressing until all the threads have reached this barrier. This functionality is a crucial aspect in synchronization to prevent inconsistencies and unsynchronized access to shared resources. It allows developers to ensure all processes are completed or all information is updated before moving on to the next step in the game's runtime. Barriers can be applied in various instances such as, but not limited to, game start-up, level completion, or during more complex inter-thread communications.",
+    "links": []
+  },
+  "lVXfA_oZr82mFfBvLnnRK": {
+    "title": "Spinlock",
+    "description": "`Spinlock` is a type of synchronization mechanism that exists in a busy-wait-state (essentially, 'spinning') until the lock can be acquired. This contrasts with other locking mechanisms that might put a thread to sleep if the desired lock is not available. It's generally used in scenarios where thread sleeping (context switching) could be costlier than spinning. However, it must be handled properly. An improperly managed spinlock can cause high CPU usage, as the wait is active; it continually consumes processing capacity. Hence, their usage is more beneficial in scenarios where the wait time to acquire a lock is reasonably short.",
+    "links": []
+  },
+  "G_BEJKkJ1_Nc43aosy_iS": {
+    "title": "Mutex",
+    "description": "`Mutex`, short for mutual exclusion, is a synchronization method used by developers to prevent multiple threads from concurrently accessing some shared resource or part of code. It is a locking mechanism that enforces limits to ensure that only one thread can perform certain operations at a time. If a `mutex` is locked by one thread, the other threads trying to lock it will be blocked until the owner thread unlocks it. This tool is essential especially in multi-threaded programming environments to avoid conditions like race conditions where the program's behavior may depend on the sequence of scheduling or timings of the threads.",
+    "links": []
+  },
+  "DYvzGc_r0SlOArPPc1gNI": {
+    "title": "Semaphore",
+    "description": "",
+    "links": []
+  },
+  "zbIbPlqTNSbJUkqH9iLQv": {
+    "title": "Future & Promises",
+    "description": "`Futures and promises` or simply `Promises` in programming is a pattern used for handling asynchronous operations. A `Promise` is an object that might produce a single value or error in the future either through a non-blocking way or in an asynchronous way. A `Promise` has three states - pending, resolved (success), and rejected (error). The Promise transitions from the Pending state to either an accomplished Resolved state, or Rejected state. These status changes are irreversible, meaning once the Promise reaches either Resolved or Rejected state, it cannot transition to any other state.",
+    "links": []
+  },
+  "o0Y_hM0KXUApfsXG4PvOY": {
+    "title": "Coroutine",
+    "description": "",
+    "links": []
+  },
+  "SXOEMkcVYBsRza6BPmmwy": {
+    "title": "Channel",
+    "description": "",
+    "links": []
+  },
+  "xR6pERldq4wPl9GVLHAhT": {
+    "title": "Condition Variable",
+    "description": "A `condition variable` is an object that has the ability to block the calling thread until notified to resume. It's used in conjunction with a `mutex` (or `lock`) in the synchronization of threads. A condition variable is made up of a mutex (or lock) and a waiting queue. Typically, a condition variable is used when a thread needs to wait until a certain condition is met. The thread will lock the mutex, check the condition, and if the condition isn't met, it will enter the waiting queue and unlock the mutex. When the condition is met, another thread will notify the condition variable, prompt it to wake up a thread from the waiting queue, and relock the mutex. It's important to mention that condition variables are subject to spurious wakeups and lost wakeups, hence developers need to manage them carefully.",
+    "links": []
+  },
+  "IeD-oQ1bkwlKNC-R0lJjZ": {
+    "title": "Thread Local Storage",
+    "description": "`Thread Local Storage (TLS)` is a mechanism by which variables are allocated such that each thread gets its own individually allocated variable, but the name of the variable is the same in each thread. In other words, the same variable can simultaneously hold different values for different threads. TLS is required when you need to use a global or static variable in a thread-safe manner but the data must be unique to each thread. TLS can be used in many applications, but it is particularly useful for storing per-thread state in server applications.",
+    "links": []
+  },
+  "mW2L_9NckgPRH7g5W9NHq": {
+    "title": "Windows",
+    "description": "In the context of server-side game development, Windows operating system offers an API for Thread Local Storage (TLS). This refers to a mechanism by which variables are allocated that are unique for each thread in a program. When a thread reads from or writes to a TLS index, it is actually referencing a thread-specific memory block. This memory block is dynamically allocated from the system heap when the thread is created and subsequently freed up when the thread is terminated. This management of memory is done implicitly by the system which can reduce complexity for developers.",
+    "links": []
+  },
+  "HU0yUyl89WD8WnR9PJn7l": {
+    "title": "pthread",
+    "description": "`Pthread` or POSIX threads is a standard-based thread programming library for multi-threading development. It provides several functions and methods to efficiently manage multiple threads in a program enhancing concurrency and parallelism. The library enables thread creation, thread joining and cancellation, thread-specific data, and synchronization including mutex locks, read/write locks, and condition variables. Notably, Pthread is an API for C/C++ programming language providing cross-platform support for Linux, Unix, and Windows systems. It's a fundamental tool for server-side game developers to create highly responsive and concurrent applications.",
+    "links": []
+  },
+  "3use5vuLBJTk40wOg9S-X": {
+    "title": "Sharding",
+    "description": "Sharding is a type of database partitioning that separates very large databases into smaller, faster, more easily managed parts called data shards. The word shard means a small part of a whole. Each shard is held on a separate database server instance, to spread load and reduce the risk of a single point of failure. Sharding can be done on a horizontal or vertical basis. Horizontal Sharding, also known as data sharding, involves putting different rows onto different tables. Vertical Sharding, on the other hand, involves putting different columns onto different tables. It's possible to shard on the basis of certain columns, and databases can be sharded in many different ways. Sharding is a complex process, but proper planning can allow for increased scalability and performance improvements.",
+    "links": []
+  },
+  "TVJrlUsg30YIM1yjsZfJI": {
+    "title": "Fiber",
+    "description": "`Fiber` is a way to manage concurrency at a more granular level than threads. While threads represent a sequence of instructions that can run concurrently with other threads, a fiber is a unit of execution which only runs on its initiating thread. Fibers are scheduled by the application, not the operating system. They are great tools for implementing co-operative multitasking where you have many tasks that you want to have run concurrently, but you want to have explicit control on when they are switched in and out. For server-side game development, fibres can be particularly useful in dealing with multiple user requests, where each request might have its own fiber.",
+    "links": []
+  },
+  "tGQu18PWDatW7HvkTP-uh": {
+    "title": "Programming Techniques",
+    "description": "Programming techniques are methods that are used to write series of instructions (code) that a computer can interpret and execute. There are many ways one can write code, unique to both the individual and the programming language they are using. Techniques such as Object-Oriented Programming (OOP) involve the use of encapsulated objects and inheritance. Functional Programming focuses on mathematical functions, avoiding changes in state and mutable data. Procedural Programming focuses on the process of executing predefined steps of functions to achieve the end result, while Event-Driven programming primarily acts upon user interactions, like mouse clicks or key presses. You can choose one technique depending on the game development requirements, the development team's competence, and preference.",
+    "links": []
+  },
+  "gB-TYpgUDV47bxznNJhYn": {
+    "title": "Design Patterns",
+    "description": "Design Patterns represent best practices developed by experienced software engineers. They are reusable solutions to common problems that occur in software design and fulfill the requirement to decouple the system as much as possible. Design patterns categorize into Creational, Structural, and Behavioural types. Creational type includes patterns like Singleton, Prototype and Factory; Structural includes Adapter, Composite, and Proxy; Behavioural includes Observer, Strategy, Template, and Visitor. Every design pattern has its own particular structure defined that programmers can follow to solve a particular design problem in your programming code.",
+    "links": []
+  },
+  "FKOhe21PVlaKIoZI4hd49": {
+    "title": "TDD",
+    "description": "`Test Driven Development (TDD)` is a development strategy in which developers write tests before writing the bare minimum of code required for the test to be passed. The process involves three stages: red, green, and refactor. In the red phase, a test is written which initially fails (since the code it's testing doesn't exist yet). In the green phase, the minimal amount of code to make the test pass is created. Lastly, in the refactor phase, the written code is improved without affecting its behavior. The process is often visualized as a cycle: \"Red - Green - Refactor\". This repeating process allows for smaller, more defined feature development, reduces bug emergence, and encourages simple design. TDD is primarily used in agile development environments.",
+    "links": []
+  },
+  "uTlxyDOtvt_Qp0gXLWO-j": {
+    "title": "Dependency Injection",
+    "description": "`Dependency Injection` (DI) is a programming technique that makes a class independent of its dependencies. This is achieved by decoupling the use of an object from its creation. In this technique, instead of a class creating an object itself, an object is supplied or \"injected\" to the class by an external entity. The actual creation and binding of dependencies are managed by a 'container', which injects the dependencies into the respective classes. Dependency Injection can be done in three ways: Constructor Injection, Setter Injection, and Interface Injection. Each of these methods involves moving the responsibility of the object creation and binding to another class or method.",
+    "links": []
+  },
+  "1c6EqGv1g-d8M1i0vKImb": {
+    "title": "Dump Analysis",
+    "description": "**Dump Analysis** is a highly useful technique in server-side game development, primarily used for debugging and troubleshooting. It involves studying the 'dump' or all the information within a system when a program crashes or fails. This dump typically includes the system's memory, the active processes, thread stacks, and more. By analyzing this data, developers can get an insight into what caused the failure. Dump analysis can be manual, using debuggers like WinDbg, lldb, gdb, or automated with tools such as Microsoft's Automatic Debugging Tool (ADPlus) and DebugDiag. Note that the complexity of dump analysis can vary depending on the nature of the program crash or the size of the dump.",
+    "links": []
+  },
+  "HXSWvhgT4L5w6xgOO-3kj": {
+    "title": "Functional Programming",
+    "description": "`Functional programming` is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. In functional programming, functions are first-class citizens. This means that functions can be passed as arguments to other functions, returned as values from other functions, and assigned to variables. Examples of functional programming languages include Haskell, Lisp, and Scala. At the heart of functional programming are the concepts of immutability and pure functions. A pure function is a function that provides the same output for the same input and has no side effects. Immutability avoids changes to variables or objects once they've been created, which makes functional programs easier to debug and test.",
+    "links": []
+  },
+  "FLFaGZDg2MSG6_YHnWETM": {
+    "title": "Databases",
+    "description": "Databases are structured sets of data. In terms of server-side game development, databases are extremely vital. They store information like user profiles, game states, rankings, and so much more. You have various types of databases to choose from such as relational databases (MySQL, PostgreSQL), NoSQL databases (MongoDB, Cassandra), and in-memory databases (Redis, Memcached). These databases have their own primary language for interaction, like SQL for relational databases. Most importantly, as a game developer, one needs to plan database schemas wisely to ensure efficient data retrieval and storage. Knowledge of indexing and a solid understanding of ACID (Atomicity, Consistency, Isolation, Durability) properties assists in developing robust game backends.",
+    "links": []
+  },
+  "QMNUAKAuRI9lyf2_jUPsj": {
+    "title": "MS SQL",
+    "description": "Microsoft SQL Server (MSSQL) is a relational database management system (RDBMS) developed by Microsoft. MSSQL provides an environment used to generate databases that can be accessed from workstations, the internet, or other media such as a personal digital assistant (PDA). Basically, MSSQL is a server-based SQL repository that provides back-end storage for applications. It supports a wide variety of transaction processing, business intelligence and analytics applications in corporate IT environments. MSSQL has various editions with different features to fulfill users' requirements, ranging from a free edition, Express, to the comprehensive Enterprise edition.",
+    "links": []
+  },
+  "HsBqd08Ro0VJnx0FlumMQ": {
+    "title": "MySQL",
+    "description": "MySQL is an open-source relational database management system (RDBMS) that uses SQL (Structured Query Language) to interact with data. It is developed, marketed, and supported by MySQL AB, a Swedish company, and is written in C and C++. Since it's open-source, you can use MySQL completely free of charge. MySQL is primarily used for online transactions and for consolidating data. You can install it on various platforms like Linux, Windows, macOS and so on. With its comprehensive set of features like support for full-text search, cursors, triggers, stored procedures, it is powerful enough to manage even very large sets of data, making it suitable for a vast range of applications, whether they be web-based or embedded.",
+    "links": []
+  },
+  "dAiEwN7phwMyaitvM5kRl": {
+    "title": "PostgreSQL",
+    "description": "**PostgreSQL** is a powerful, open-source object-relational database system. It extends the SQL language combined with many features that safely store and scale the most complicated data workloads. The origins of PostgreSQL date back to 1986 as part of the POSTGRES project at the University of California at Berkeley. It has earned a strong reputation for its proven architecture, reliability, data integrity, robust feature set, extensibility, and the dedication of the open-source community behind the software to consistently deliver performant and innovative solutions. PostgreSQL runs on all major operating systems and has been ACID-compliant since 2001. It has powerful add-ons like the popular PostGIS geospatial database extender. It can handle ranges, array types and has extensive capabilities for developing at scale.",
+    "links": []
+  },
+  "9vc7sFE_XakYXtKRMxLXi": {
+    "title": "DynamoDB",
+    "description": "DynamoDB is a NoSQL database service provided by Amazon that delivers reliable performance at any scale. It's a fully managed, multiregion, multimaster database that offers built-in security, backup and restore, and in-memory caching. It's meant to support applications with large scale, low latency requirements. Developers can create database tables that can store and fetch any amount of data and can serve traffic from a few requests per month to millions of requests per second. As a part of AWS, DynamoDB integrates well with other AWS services and provides developers with high availability across multiple geographical regions.",
+    "links": []
+  },
+  "HYxtPW401-J6aYcTuiGnx": {
+    "title": "MongoDB",
+    "description": "MongoDB is a source-available NoSQL database program that uses a document-oriented database model. This model supports a variety of data types and enables you to store them in one place. MongoDB uses JSON-like documents coupled with optional schemas. What distinctly characterizes MongoDB is its scalability and flexibility that allow schemas to evolve with business needs. It can run over multiple servers, the data is duplicated to facilitate keeping the system up and the data available. Also, MongoDB supports rich queries through its powerful querying and aggregation tools. These capabilities encourage fast development and iterations. However, bear in mind that like any database, MongoDB is not a one-size-fit-all solution and understanding its best use cases is crucial for maximizing its benefits.",
+    "links": []
+  },
+  "1jqSxk1nwByiQa1De81F3": {
+    "title": "Cassandra",
+    "description": "Apache Cassandra is an open-source, distributed NoSQL database system that is designed to manage large volumes of data across a wide range of servers. It provides high availability with no single point of failure. Cassandra is often used for applications where data is distributed across multiple locations as it has superior replication mechanisms. It utilizes a peer-to-peer architecture, as opposed to master-slaves, which allows for continuous availability and scalability. Cassandra also provides robust support for clusters spanning multiple datacenters, with asynchronous masterless replication allowing low latency operations for all clients.",
+    "links": []
+  },
+  "6KTj_giX2k9l2lPd_Fp-d": {
+    "title": "Couchbase",
+    "description": "Couchbase is a NoSQL database technology that provides flexible data models suitable for server-side game development. It provides high-performance and easy scalability, offering a comprehensive platform for managing, manipulating and optimizing data in real-time. The technology behind Couchbase combines the powerful performance of key-value stores with the flexible querying capabilities of SQL-like querying systems. This makes it particularly valuable in gaming environments where performance and flexibility are crucial. Moreover, Couchbase also provides document database capabilities, allowing for complex documents to be stored in a format that can be easily manipulated for individual needs. With its high performance, flexible querying, and document database capabilities, Couchbase is a powerful tool for server-side game developers, and mastering it can significantly enhance your development capabilities.",
+    "links": []
+  },
+  "7YNaELVcoV7DV1Fa06USi": {
+    "title": "Redis",
+    "description": "`Redis` is an open-source, in-memory data structure store that can be used as a database, a cache, and a message broker. It provides support for various data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, and more. Redis also allows atomic operations like appending to a string; increasing and decreasing hash, array and sorted sets values; computing set intersection, union and difference; and much more. An interesting feature of Redis is its ability to create transactions and also publish and subscribe to channels. It is a great choice for high-performance software like games because of its versatile nature and efficient performance.",
+    "links": []
+  },
+  "ayeezKxQkXAPJMTShsOBU": {
+    "title": "Memcached",
+    "description": "`Memcached` is a high-performance, distributed memory object caching system that is generic in nature, but intended for use in speeding up dynamic web applications by alleviating database loads. It does this by storing data and objects in dynamic memory to reduce the frequency with which an external data source must be read. `Memcached` is fundamentally a key-value store that operates over the network. It uses a client–server architecture where the servers maintain a common view of the data set. The clients are responsible for partitioning data and determining to which servers data items are to be written or from which servers they are to be read.",
+    "links": []
+  },
+  "OyxWMFy8s7Lxko_K89fjo": {
+    "title": "ORM",
+    "description": "ORM stands for Object-Relational Mapping. In server-side game development, ORM is a technique that lets you interact with your database, like you would with SQL. In other words, on the server side, you create classes in your programming language (e.g., Python, JavaScript, etc.) that map to the tables in the database. Each instance of a class represents a row in the respective table. ORM libraries and tools provide methods to perform CRUD (Create, Retrieve, Update, Delete) operations without having to write raw SQL statements. Popular examples of ORM tools include Sequelize for JavaScript, SQLAlchemy for Python, and Hibernate for Java.",
+    "links": []
+  },
+  "dt_SmZuwklLimhupvjxC1": {
+    "title": "DAL",
+    "description": "The term **DAL** stands for **Data Access Layer**. It represents a layer of an application that simplifies the interaction with the persistent storage of data. Typically, the DAL is implemented in a separate module, package, or library in your application that directly communicates with the database, thereby enabling the application services and modules to invoke a simple API for CRUD operations (Create, retrieve, update, and delete database entries) and database transactions. The DAL helps maintain the application’s database schema and manage connections to the database. Popular libraries and frameworks like SQLAlchemy for Python, Sequelize for Node.js, and Hibernate for Java among others provide a robust DAL implementation. These tools abstract the lower-level details of the data source into a higher-level programming interface.",
+    "links": []
+  },
+  "1788KFqsQBkYARqA0T5GX": {
+    "title": "Cipher",
+    "description": "**Cipher** is a vital component in the field of cryptography and is used to encrypt and decrypt information. It is essentially a series of well-defined steps or algorithms followed to convert sensitive information or data into a form that appears to be random and meaningless. This transformed information can only be turned back into its original form with a specific decryption key. Based on their methodology, ciphers are broadly classified into two categories: block ciphers and stream ciphers. Block ciphers work on a chunk of data at once, whereas stream ciphers work on a individual bits or bytes. Examples of ciphers include: Caesar Cipher, Monoalphabetic Cipher, and Vigenere Cipher among others. Usage of ciphers enhances the security in server-side game development by ensuring that player data remains confidential and is not subjected to unauthorized access or manipulation.",
+    "links": []
+  },
+  "PSvPjaVtko71BeIA-hYqf": {
+    "title": "SSL",
+    "description": "Secure Sockets Layer (SSL) is a security protocol which provides encrypted communication between a web browser and a web server. This protocol operates via a process where the SSL certificate, held by the web server, creates two cryptographic keys - a Public Key and a Private Key. The public key is placed into a Certificate Signing Request (CSR) - a file also containing detailed information about the web server and your organization. A certificate authority then validates these details and issue an SSL certificate for your web server. This SSL certificate contains the new, unique public key for your web's session data. When a browser connects to this web server and the SSL handshake is complete, an encrypted SSL session is established via the protocols of symmetric cryptography. It's noteworthy to mention that even though SSL has been succeeded by Transport Layer Security (TLS), people still refer to these certificates as SSL.",
+    "links": []
+  },
+  "YxaroYL_Az0vKRCeu2jsp": {
+    "title": "RPC / REST",
+    "description": "RPC (Remote Procedure Call) and REST (Representational State Transfer) are two different approaches to client-server communication. RPC is a procedure-oriented service, where the client sends a request to the server invoking a specific procedure along with the parameters it needs to execute. The server-side program then processes these inputs and returns the result back to the client. On the other hand, REST is a resource-oriented architecture, leveraging standard HTTP methods like GET, POST, PUT, DELETE to perform operations. In REST, every single information or service is considered as a \"resource\".\n\nIn the context of game development, both RPC and REST can be used depending on the specific needs of the game and the underlying architecture that supports it. Both of them offer unique characteristics that make them suitable for different aspects or modules inside a game like character control, game state management, real-time networking, etc. While RPC might be more suited for real-time, fast communication, REST can be leveraged for independent, scalable, and stateless nature of its design.\n\nIn sum, RPC and REST terms come up frequently in server-side game development due to their importance in determining how your game will communicate between its different parts, especially in multiplayer environments. It is crucial to make the appropriate choice based on your game's requirements and desired user experience.",
+    "links": []
+  },
+  "Oq3GQ5gBUxIl1Qe8NB3LB": {
+    "title": "REST",
+    "description": "REST or Representational State Transfer is an architectural style used in web development. REST systems interact through standard operations on web resource's identified through URIs. It utilizes a stateless, client-server, cacheable communication protocol -- virtually always HTTP. In REST architecture, a client sends a request to the server in order to retrieve or modify data. This data can be identified by a URI and has a specific media type (JSON, XML etc). A key feature of REST is that it's stateless, meaning the server does not keep any data between two requests. While the client holds session state. REST is often used in mobile applications, social networking websites, and automated business processes.",
+    "links": []
+  },
+  "_uqTTBUYAzDHbEUkDzmzg": {
+    "title": "gRPC",
+    "description": "`gRPC` (Google Remote Procedure Call) is a high-performance, open-source universal RPC framework designed by Google. The gRPC framework supports a wide range of languages, and it is based on the proto3 protocol buffer (protobuf) language. It uses Protocol Buffers as the interface definition language for defining the method parameters service and return types. gRPC is designed to work over a variety of different pluggable transports and also supports load balancing, tracing, health checking and authentication. It's functionality is particularly suited for point-to-point services within a microservice architecture.",
+    "links": []
+  },
+  "cw7WdFfL5HpeZ_n8wYk2t": {
+    "title": "Message Queues",
+    "description": "Message queues are a fundamental element of server-side game development, primarily used for communication and data exchange between different processes, threads, or microservices. A message queue operates on the principle of first-in, first-out (FIFO). In the typical process, a sender submits messages to the queue, and receivers extract messages from the queue. This mechanism ensures seamless coordination between different parts of a system performing at different speeds and allows asynchronous information exchange. Features such as persistence, delivery acknowledgement, prioritization, and scheduling are commonly associated with message queues. Different technologies support message queues including RabbitMQ, Apache Kafka, and AWS SQS among others. The choice of the appropriate message queue technology can depend on specific requirements, such as the relevant programming language and the expected size and rate of message traffic.",
+    "links": []
+  },
+  "gL7hubTh3qiMyUWeAZNwI": {
+    "title": "Apache Kafka",
+    "description": "Apache Kafka is an open-source stream-processing software platform developed by LinkedIn and donated to the Apache Software Foundation. It is written in Scala and Java and operates based on a message queue, designed to handle real-time data feeds. Kafka functions as a kind of message broker service in between the data producers and the consumers, facilitating efficient transmission of data. It can be viewed as a durable message broker where applications can process and reprocess streamed data. Kafka is a highly scalable and fault-tolerant system which ensures data delivery without loss.",
+    "links": []
+  },
+  "UESjGrFyUbNf4pQamaBoy": {
+    "title": "RabbitMQ",
+    "description": "RabbitMQ is an open-source message broker software that implements the Advanced Message Queuing Protocol (AMQP). It's designed to offer a common platform for passing messages between different parts of a system or between separate systems. RabbitMQ allows these parts to speak and understand each other even if they’re written in different programming languages or implemented on different platforms. RabbitMQ is not just limited to AMQP protocol but supports a variety of different messaging protocols including MQTT, STOMP, and more. Also, RabbitMQ is language agnostic, meaning it can be used with almost any programming language. In addition, it comes with a web user interface for managing and monitoring your RabbitMQ server. It's widely used in production systems around the world and can support large scale distributed systems as it supports clustering and fail-over.",
+    "links": []
+  },
+  "_jd91rrAXGbJI9RhXlSx8": {
+    "title": "Multithreading",
+    "description": "`Multithreading 2` in game development usually refers to an advanced level of understanding, managing, and implementing multithreaded programming. At this stage, developers are expected to manage inter-thread communications and synchronization effectively. This includes mastering the use of mutexes, locks, semaphores, and condition variables. This level extends to the fine-tuning of performance and resolving complex issues such as race conditions, deadlocks, and starvation. Furthermore, it could cover advanced topics like thread-pools and executing modern multithreaded game architectures efficiently and safely. In multithreading 2, developers learn to leverage more concurrent computing power, thus making the server more performant and responsive.",
+    "links": []
+  },
+  "KUQEgHldZPOLwFoXqQ2vM": {
+    "title": "Actor Model",
+    "description": "The **Actor Model** is a conceptual model to deal with concurrent computation. It defines some general rules for how the system's components should behave and interact with each other. In the Actor Model, each object (actor) has its own private state and communication with other actors is done by exchanging messages. Actors read messages from a personal mailbox and may change their own inner state, create more actors, or send messages to other actors. The Actor Model makes it easier for developers to write concurrent and distributed systems by providing high-level abstractions over low-level threading details.",
+    "links": []
+  },
+  "SsOz9Pj6Jc_55PgpmziL6": {
+    "title": "Akk.net (C#)",
+    "description": "\"[Akka.NET](http://Akka.NET)\" is a toolkit and a runtime for designing concurrent and distributed applications. This technology is directly inspired by the Actor Model concept, implementing its principles to create robust and highly functional server-side applications. [Akka.NET](http://Akka.NET) allows developers to create systems that are capable of handling millions of messages in a concurrent manner while maintaining high performance. It supports actor-based concurrency, network and cloud distribution, and powerful event sourcing techniques. Building systems with [Akka.NET](http://Akka.NET) involve not only working with primary actors but also working with different types, including the likes of Persistent actors, FSM (Finite State Machine) actors and more. Please remember, [Akka.NET](http://Akka.NET) is a part of the broader Akka toolkit, which also includes libraries for Java and Scala.",
+    "links": []
+  },
+  "eAEpEUVZcSKO9uCIlMN5y": {
+    "title": "Akka (Java)",
+    "description": "Akka is an open-source toolkit and runtime simplifying the construction of concurrent and distributed applications on the JVM. It implements the Actor Model for handling concurrency, allowing developers to create systems that can handle high volumes of transactions in a distributed environment. Yet, Akka is not only about Actors, it features other tools for building reactive applications, including Event Sourcing, CQRS, Cluster Sharding, and Distributed Data. Written in Scala and providing APIs in both Scala and Java, Akka powers numerous business-critical systems in sectors such as finance, tech, streaming, and others.",
+    "links": []
+  },
+  "ThBxS9xIMt9OrXfnto3rW": {
+    "title": "Asynchronous",
+    "description": "**Asynchronous programming** is a programming paradigm where the execution of functions or routines does not wait for the activities within them to complete before moving on to subsequent ones. This allows for tasks to be processed independently, making the most of system resources. When a function contains an operation such as I/O, database access, or network communication, which may take a long time to complete, this function is wrapped into a future or promise and sent for execution. Meanwhile, the core program continues to run. When the wrapped function gets executed, a callback function is used to notify that the computation or I/O is complete. This forms the core of non-blocking or asynchronous execution. It is widely used in server-side programming, game development, and any scenario where I/O latency or user experience is a concern. Notably, it is at the core of Node.js and many modern web frameworks.",
+    "links": []
+  },
+  "7mYpgn2gr-5vAYW-UR7_x": {
+    "title": "Reactor",
+    "description": "The **Reactor** is a design pattern that deals with synchronous I/O multiplexing. It is a part of the server side game development concept where it mainly handles service requests delivered concurrently to an application by one or more clients. The reactor allows multiple requests to be managed efficiently by the resources of a single thread. It uses an event loop and callbacks to control and manage all the different I/O streams. Often, Reactor is combined with the Proactor pattern to achieve concurrency and efficiency in utilizing system resources.",
+    "links": []
+  },
+  "5-5toy2CblZPCV9d5QPEo": {
+    "title": "select",
+    "description": "",
+    "links": []
+  },
+  "D9Yeyn8phDhB1ohMWccgr": {
+    "title": "WSA Poll",
+    "description": "",
+    "links": []
+  },
+  "qaWv4gxnnj3uX8lEm9KQ4": {
+    "title": "epoll",
+    "description": "",
+    "links": []
+  },
+  "caK32NMMrn-3BGAXZoPPr": {
+    "title": "kqueue",
+    "description": "",
+    "links": []
+  },
+  "Tvxe2NemcH21y-eB4bosv": {
+    "title": "Proactor",
+    "description": "The **Proactor** pattern is an event-driven application design pattern used in asynchronous programming, and is a variant of the Reactor Pattern, but with an important distinction in terms of control flow handling. Instead of the application explicitly triggering and managing operations, this responsibility is delegated to the asynchronous operation processor, also known as the proactor. The proactor initiates an asynchronous operation, and once the operation is complete, it determines the appropriate service to dispatch the completion event to. In other words, proactors are responsible for initiating asynchronous operations, while completion handlers are responsible for dictating what happens next, after the operations complete.",
+    "links": []
+  },
+  "7pgdOZomhGilBTwfJLMbm": {
+    "title": "IOCP",
+    "description": "",
+    "links": []
+  },
+  "YH7u1FKh85wz78J0stuzS": {
+    "title": "io_uring",
+    "description": "",
+    "links": []
+  },
+  "94hJX1iGifDzIuaU3zU5j": {
+    "title": "Registered IO",
+    "description": "",
+    "links": []
+  },
+  "LKPcEeqBOPhQOztD3cM3T": {
+    "title": "Task-Based",
+    "description": "Task-based multithreading refers to a model where tasks are the units of work abstracted from threads. In this model, application logic is divided into smaller tasks, each capable of running independent of the others. The tasks are then executed by a pool of threads, managed by a scheduler. Unlike traditional thread-centric models where each thread performs a specific task, task-based multithreading allows for greater flexibility by decoupling the tasks from the threads and letting the system dynamically assign tasks to idle threads. With task-based multithreading, developers no longer need to manually manage threading details like creation, control, synchronization, and termination, hence enabling more focus on the development of the game logic.",
+    "links": []
+  },
+  "f-L_eaZd0EjBW9-n9Pllt": {
+    "title": "goroutine (Go)",
+    "description": "`Goroutine` is a lightweight thread managed by the Go runtime. They are functions or methods that run concurrently with other functions or methods in the Go programming language. Goroutines are cheaper than threads as they use less memory, and their creation and destruction are more efficient in terms of performance. Unlike threads in other languages, the Go runtime manages the scheduling of Goroutines, taking a lot of the complexities away from the developer. Goroutines are one of the unique features of Go, making it an excellent choice for concurrent programming, especially useful in server-side game development.",
+    "links": []
+  },
+  "RT9XvlxvIM_hHTtNmbva3": {
+    "title": "Concurrency (Java)",
+    "description": "Concurrency is a property of systems that allows multiple tasks to run in an overlapped or simultaneous manner. This is widely used in server side game development where it is common to have multiple players interfacing with the system at the same time. It is essential to keep the system responsive and efficient under high load. Concurrency is often achieved through multithreading or asynchronous programming. Multithreading involves multiple threads of execution within a single program, with each thread running on a separate processor core. Asynchronous programming, on the other hand, achieves concurrency by allowing tasks to progress without waiting for other tasks to complete. This can be particularly useful in situations where tasks involve I/O operations or network requests, which can take a significant amount of time to complete, and would otherwise block the execution of other tasks.",
+    "links": []
+  },
+  "mAXMpUDmhGOncnCRrENJv": {
+    "title": "Asnc-await (C#)",
+    "description": "`Async/await` are extensions of Promises in JavaScript that allow for handling asynchronous code in a more synchronous manner. Using `async` keyword before a function, means the function returns a Promise. On the other hand, `await` keyword is used to pause async function execution until a Promise is resolved or rejected, and to resume execution of the async function after fulfillments. Before the `await` keyword, the Promise resolves to the actual value. Notably, `await` only works within async function block.",
+    "links": []
+  },
+  "tiG0mZpLJ2zUr2IPYyhnv": {
+    "title": "Thread Building Block (C++)",
+    "description": "The **Thread Building Blocks** (TBB) is an open-source C++ library developed by Intel. It is designed to take advantage of multi-core processors by simplifying the process of deploying parallel tasks. Using TBB, you can easily break down your tasks into smaller sub-tasks that can be processed in parallel, improving the speed and efficiency of your game server. TBB encompasses generic parallel algorithms, concurrent containers, a scalable memory allocator, work-stealing task scheduler, and low-level synchronization primitives. However, it's not a library for threading as POSIX or Win32 threads, rather, it's a higher-level, task-based parallelism that abstracts platform details and threading mechanism for performance and scalability.",
+    "links": []
+  },
+  "Vl-WW0LThrQTOO_tFl51B": {
+    "title": "Reactive Approach",
+    "description": "",
+    "links": []
+  },
+  "yWj70LpF4LKB8J6GbYvsq": {
+    "title": "OORP",
+    "description": "**Object-Oriented Reactive Programming (OORP)** is a programming paradigm that combines object-oriented programming (OOP) and reactive programming. In OORP, developers design the system in terms of objects that communicate with each other through messages. These messages trigger functions or \"reactions\" in the receiving objects, hence the term \"reactive\". Each object in OORP encapsulates state and behavior, follows inheritance, and promotes data abstraction, similar to traditional OOP. However, OORP operates in a more event-driven manner, responding to external events, changes, or transactions that occur over time or in response to other objects.",
+    "links": []
+  },
+  "xDYOvIbXc-iJ2zOKqe0YL": {
+    "title": "FRP",
+    "description": "`Functional Reactive Programming (FRP)` is an approach to programming that combines functional and reactive concepts, mainly used in front-end and server-side development especially in games. FRP helps to deal with dependent changes, effectively handling 'time-varying values'. It is the elegant solution to describe systems where the current state depends on the future or the past state in a clear and efficient way. Its major concepts include streams (sequences of events over time), observers (consumers of values from a stream), and observables (producers of values), which are the heart of the FRP system. Through these characteristics, it manages data flows and propagation of change making software logic more readable and easier to understand.",
+    "links": []
+  },
+  "p0P3ZGq_QTCop0vMwe7P3": {
+    "title": "Reactive Model",
+    "description": "The Reactive Model is an approach in server-side game development that positions the server as a responder to requests made by the client. In this model, the server is not running its own threads, but simply reacting to incoming requests from clients. It focuses on asynchronous I/O operations, meaning that the system doesn't stall or wait for data to be written or read. When the client sends a request, the server reacts by performing a specific action, like accepting a network connection or reading data. It is built around the idea of event-driven programming, where logic is coded against events, ideally resulting in highly scalable systems. It's often used in conjunction with non-blocking I/O models, such as Node.js or other event-driven architectures.",
+    "links": []
+  },
+  "l5QTk408Ubagw8XzRAfoZ": {
+    "title": "Synchrony",
+    "description": "In a reactive paradigm, \"synchrony\" is a key concept related to data management and interactions among multiple components in a server-side game development context. It refers to the idea that operations or processes are executed 'in sync', meaning that the next operation starts strictly after the previous operation has already finished. In a synchronous communication, for instance, the sender can't start a new communication until the receiver confirmed receiving the last parcel. It's different from \"asynchrony\" where various operations can run concurrently, not waiting for previous operations to finish before moving on. Overall, understanding the concepts of synchrony and asynchrony are crucial for making efficient use of resources in server-side game development, and picking the right approach depends on the specific use case and requirements.",
+    "links": []
+  },
+  "zFx1jjt1hKgCpYHFTzbZZ": {
+    "title": "Determinism",
+    "description": "\"Determinism\" in the context of server side game development is a principle that highlights predictability and consistency in the system's output given specific and consistent inputs. It implies that a system will always produce the same outcome if the initial conditions and the sequence of events leading up to the outcome are identical. Determinism is incredibly important and beneficial in multi-player gaming situations like MMORPGs where synchronized and equal gameplay across all user instances is key. This level of predictability helps in offering a fair play environment to all players and in ease of debugging and replaying certain sequences for the developers.",
+    "links": []
+  },
+  "3Eat22rFjUl4eTtGz8u4N": {
+    "title": "Update Process",
+    "description": "In the reactive model, the client sends requests to the server, which then processes the request and sends back a response. This model is called 'reactive' because the server only acts or 'reacts' when it receives a request from the client. The \"update process\" plays a vital role in this model. It's the server's responsibility to keep the game world updated and synchronized among all players. This updating process is typically done in a loop that processes all the changes that happen in the game like players’ actions, NPC movements, in-game events or game physics. It updates the game world and informs the players about the changes. Also, if a player makes changes like moving a character or attacking an enemy, it sends this information to the server adding it to the update loop. The frequency of this updating process is often referred to as 'tick rate'.",
+    "links": []
+  },
+  "LVwGXmZhMewGQy61qwNyu": {
+    "title": "Reactive Approach",
+    "description": "In the realm of server-side game development, the reactive approach is an important element when dealing with multithreading. This approach is based on the concept of reacting to changes or events happening in the system rather than calling methods or running operations continuously. It incorporates observables, which are objects that represent a stream of data or a series of events, and observers, which are methods that respond to the events or changes in these observables. Reactive programming is based on the observer pattern and is designed to handle asynchronous data calls and events efficiently. This pattern is particularly relevant in situations with a large amount of data, high level of complexity, or stringent real-time requirements. With this approach, it is also simpler to handle concurrency and to write programs that are efficient, clean, and less prone to errors and callback pyramids.",
+    "links": []
+  },
+  "hhtqvFfTCuVPT0OPu4Y1a": {
+    "title": "Cloud",
+    "description": "The **cloud** refers to servers that are accessed over the Internet, and the software and databases that run on those servers. By using cloud technology, data can be accessed from anywhere via the Internet, rather than from a local server or a personal computer. Cloud services are typically provided by different companies, such as Google, Amazon, and Microsoft. There are three main types of cloud computing: Infrastructure as a Service (IaaS), Platform as a Service (PaaS) and Software as a Service (SaaS). Examples of the cloud in gaming include multiplayer online games, game streaming and digital distribution platforms. The cloud is also used in game development for testing, development, and distribution of games.",
+    "links": []
+  },
+  "73uoFNGcCALxIuRNbebav": {
+    "title": "Azure",
+    "description": "Azure is Microsoft's public cloud computing platform. Azure provides a broad spectrum of cloud services, including those for analytics, storage, and networking. As a server-side game developer, you can use these functionalities to build, deploy, and manage applications and services through Microsoft-managed data centers. Furthermore, Azure supports a wide range of tools and frameworks, including both Microsoft-specific and third-party software. It also offers 4 different forms of cloud computing: infrastructure as a service (IaaS), platform as a service (PaaS), software as a service (SaaS), and serverless. Each allows developers to choose the level of control and complexity they wish to maintain over their application and infrastructure.",
+    "links": []
+  },
+  "wD6dUrS-tP2gpCHPghFp5": {
+    "title": "GCP",
+    "description": "**Google Cloud Platform (GCP)** is a suite of public cloud computing services offered by Google. It provides a range of services including compute, storage, networking, Big Data, machine learning, and the internet of things (IoT), plus cloud management, security, and developer tools. The core cloud computing products in GCP consist of Google Compute Engine, Google App Engine, Google Container Engine, Google Cloud Storage, and Google Cloud SQL. Google also offers cloud services for source code management, load balancing, security and privacy, and more. The architecture of GCP is built on the same infrastructure that Google uses for its global products such as YouTube, Google Search, and Google Maps.",
+    "links": []
+  },
+  "Rkx2A6oWsddlCTseZlpRU": {
+    "title": "AWS",
+    "description": "**Amazon Web Services (AWS)** is a secure cloud services platform offered by Amazon. It provides a broad set of infrastructure services, such as computing power, storage options, networking and databases, delivered on-demand with pay-as-you-go pricing. AWS services assist server side game developers in many tasks such as storing player data, syncing games across devices, and even hosting multiplayer game servers. These services help developers scale their games to a world-wide audience without the need for up-front investments in costly hardware and infrastructure. A popular choice for start-ups and large game development companies alike, AWS has an extensive, feature-rich set of tools that allow developers to deploy, monitor and scale applications quickly.",
+    "links": []
+  },
+  "DOmbRRK_RRPElOuTB7AAK": {
+    "title": "Serverless",
+    "description": "**Serverless** is a cloud architecture model where the application developers don't have to provision, scale, and manage servers or runtimes, to build their applications. The name serverless comes from the idea that the tasks traditionally performed by a server are handled elsewhere, abstracting the responsibility of managing servers away from the developer. Developers can write and deploy code without worrying about the underlying infrastructure. A serverless model uses backends as a service (BaaS) and functions as a service (FaaS), providing automatic scaling, patching, and capacity provisioning. Popular examples of serverless providers are AWS Lambda, Google Cloud Functions, and Azure Functions.",
+    "links": []
+  },
+  "XCJvgUSS7-oDR-XGdDY33": {
+    "title": "Data Clustering",
+    "description": "`Data Clustering` refers to the process of segregating data into various groups or clusters. These organized subsets of data, or clusters, contain similar data points that exhibit common traits, attributes, or characteristics. Clustering is essentially a type of unsupervised machine learning where the data is unlabeled, and the algorithm identifies similarities to group them together. There are several methods used for data clustering including partitioning methods like K-means, hierarchical methods, density-based methods like DBSCAN, and grid-based methods. These methods differ based on how they form the clusters and the types of data they work best with. Data clustering aids in the organization of large amounts of data, making it easier for developers to handle, understand, and utilize in game development.",
+    "links": []
+  },
+  "yrWiWJMSyTWxDakJbqacu": {
+    "title": "Apache Spark",
+    "description": "Apache Spark is an open-source, distributed computing system used for big data processing and analytics. It offers an interface for programming entire clusters with impeccable data parallelism and fault tolerance. With its high-level APIs in Java, Scala, Python and R, it provides a framework for distributed task dispatching, scheduling and basic I/O functionalities. Notable modules include SQL and DataFrames, MLlib for machine learning, GraphX for graph processing, and Structured Streaming for incremental computation and stream processing. Apache Spark can run standalone, on Hadoop, or in the cloud, and is capable of accessing diverse data sources such as HDFS, Apache Cassandra, Apache HBase, and Amazon S3.",
+    "links": []
+  },
+  "k3FJY26SVxdZx4MLLE25h": {
+    "title": "Containerization",
+    "description": "Containerization in game development refers to the usage of software like Docker, Kubernetes, or similar tools to encapsulate the game's server-side functionality into a single, deployable package. These units, known as containers, include everything the software needs to run, such as libraries, system tools, code, and runtime. Containers are platform-agnostic, meaning they can work across different operating environments in the same way. This enables developers to create a consistent experience, reduce the risk of software conflicts, and facilitate easier updates and deployment of their games. Unlike Virtual Machines (VMs), containers do not include whole operating systems, which makes them more lightweight and efficient to run. Developers can run multiple containers on the same machine, each handling different aspects of the server-side functionality. Containers can also communicate with each other, enabling more efficient use of resources.",
+    "links": []
+  },
+  "zW_7VLeEHQp8fp_f5N__0": {
+    "title": "Docker",
+    "description": "\"Docker\" is an open-source platform that allows developers to automate the deployment, scaling, and management of applications. It uses containerization technologies to wrap up an application with its runtime environment into a container, which can then be run on almost any operating system. Docker containers are lightweight and fast because they do not need the extra load of a hypervisor, but run directly within the host machine's kernel. Additionally, Docker ensures that the application runs seamlessly in any environment by bundling its own software, libraries and system tools. Docker really simplifies the process of managing and deploying services in a distributed environment and breaking down tasks into separate services.",
+    "links": []
+  },
+  "yAf7VDX7dyaT5AdlNnuKD": {
+    "title": "Docker Compose",
+    "description": "`Docker Compose` is a tool that allows you to define and manage multiple containers as a single entity. The containers are defined in a `docker-compose.yml` file using a YAML format. This tool is primarily focused on the runtime aspects of your application such as service definitions, configuration, and connections. With `Docker Compose`, you can start, stop, and manage the entire stack of services with a single command. This makes it a very powerful tool for managing multi-container applications. It is also a good method to define a local development environment that mimics your production environment.",
+    "links": []
+  },
+  "lUBUUoETjfADmM4OPtwwX": {
+    "title": "Kubernetes",
+    "description": "Kubernetes, often referred to as K8s, is an open-source platform designed to automate deploying, scaling, and operating application containers. It organizes containers into clusters to provide a flexible, powerful foundation for distributed systems. The platform was originally developed by Google, drawing on their long experience with managing containerized applications. It groups an application's containers into logical units for easy management and discovery. Kubernetes offers features like automatic bin packing, horizontal scaling, automated rollouts and rollbacks, and storage orchestration, among many others. It supports a variety of underlying infrastructures, from physical servers to virtual machines and cloud-based deployments, allowing you to run your apps wherever and however you choose.",
+    "links": []
+  },
+  "dkCVwuy8GKeEi3VJar_Zo": {
+    "title": "AI",
+    "description": "Artificial Intelligence (AI) in server side game development refers to the use of algorithms and computational procedures to create systems capable of performing tasks that would require human intelligence. Such tasks include learning and adapting to change, recognizing speech, or even making decisions. In game development, AI is often used to give non-player characters (NPCs) their own 'intelligence', making them even more life-like. This could be as simple as the ability to follow a player around in an environment, or as complex as crafting strategies for combat. AI can also be used to generate procedurally or dynamically generated content, creating potentially infinite unique experiences for the player. AI in games is often programmed in a way where it must strike a balance between appearing intelligent and providing an enjoyable experience for the player.",
+    "links": []
+  },
+  "XvvlvDKfYRCcYtTdWohsd": {
+    "title": "Cloud ML",
+    "description": "`Cloud Machine Learning` or `Cloud ML` is a branch of Artificial Intelligence that utilizes cloud computing services to provide machine learning capabilities. It enables developers and data scientists to build, train, and deploy machine learning models in a cloud-based environment. Cloud ML platforms usually offer a range of pre-trained models and services for tasks like image recognition, natural language understanding, and predictive analytics. These platforms support popular ML frameworks, such as TensorFlow and PyTorch, which can be used to design custom models. Importantly, Cloud ML abstracts the complex infrastructure management associated with large-scale ML computations providing users with more agile, scalable, and accessible machine learning solutions.",
+    "links": []
+  },
+  "U0RlO_puezQPZP0-iBXgW": {
+    "title": "Amazon ML",
+    "description": "Amazon Machine Learning (Amazon ML) is a robust, cloud-based service that makes it easy for developers of all skill levels to use machine learning technology. It provides visualization tools and wizards that guide you through the process of creating machine learning (ML) models without needing to learn complex ML algorithms and technology. With Amazon ML, you can create and train your data models, and then use those models to make predictions. These predictions can be used to implement sophisticated applications, such as user trend detection, sentiment analysis, fraud detection, and much more.",
+    "links": []
+  },
+  "vBqwmlzoT5XVEhV9IeGso": {
+    "title": "Azure ML",
+    "description": "Azure ML is a cloud-based service provided by Microsoft for building, training, and deploying machine learning models. It provides a suite of tools including automated machine learning and model management services, bolstering the productivity of data scientists and making complex machine learning tasks more achievable. Azure ML is designed to work with popular data science and machine learning frameworks such as PyTorch, TensorFlow, and scikit-learn. It bestows the capabilities of handling large volumes of data, providing scalability, and offering real-time insights. Furthermore, it supports open-source technologies, making it flexible for a wide array of applications. Azure ML stresses on high-level security and compliance, complying with major global and industry-specific standards. It's a comprehensive tool aimed at accelerating the entire machine learning lifecycle.",
+    "links": []
+  },
+  "jkWvfp4GqckYPQ48GtjlR": {
+    "title": "Deep Learning",
+    "description": "Deep Learning is a subset of machine learning that imitates the workings of the human brain in processing data and creating patterns for decision-making. This technique utilizes multiple layers of algorithms (or neural networks) to process information. Deep learning involves training a model using large volumes of data and neural network architectures that contain many layers. A server-side game developer might use deep learning algorithms to create complex AI characters, improve game physics, or even analyze player data. Deep learning can be supervised, semi-supervised or unsupervised and it's extensively applied in various domains such as voice recognition, image recognition, natural language processing, etc. It is a crucial element for many modern AI applications.",
+    "links": []
+  },
+  "iJE9RnKC8QjPnsFeZAbtl": {
+    "title": "TensorFlow",
+    "description": "**TensorFlow** is an open-source, end-to-end platform initially developed by Google Brain Team. Focusing on machine learning and equipped to handle deep learning tasks, TensorFlow takes input as a multi-dimensional array also known as a 'tensor'. The framework allows developers to create dataflow graphs. These graphs describe how data moves in a computing unit, be it a machine or a cloud. Within the graph, nodes represent mathematical operations while edges symbolize the tensors. TensorFlow is highly scalable and allows for computations across multiple CPUs or GPUs, making it appropriate for various tasks - be it server-side game development or research.",
+    "links": []
+  },
+  "LTSIfq10qDJMTCnIIyqvb": {
+    "title": "Pytorch",
+    "description": "**PyTorch** is an open-source machine learning library developed by Facebook Artificial Intelligence Research team for Python-based computation. This powerful tool emphasizes flexibility and allows users to manipulate Tensor computations with the convenience of deep neural networks built on a tape-based autodifferentiation system. It provides a great platform for implementing deep learning models and is very popular for understanding and expressing dynamic neural networks. PyTorch supports dynamic computational graphs, which means the graph structure can be modified during runtime. This is particularly useful while working with recurrent neural networks. It integrates seamlessly with the python data science stack to leverage the power of libraries such as NumPy.",
+    "links": []
+  }
+}

public/roadmap-content/technical-writer.json

@@ -0,0 +1,438 @@
+{
+  "HlUUGj3dOZ68t4gIjerXh": {
+    "title": "Introduction",
+    "description": "Technical writing involves explaining complex concepts in a simple, easy-to-understand language to a specific audience. This form of writing is commonly utilized in fields such as engineering, computer hardware and software, finance, consumer electronics, and biotechnology. The primary objective of a technical writer is to simplify complicated information and present it in a clear and concise manner. Duties of a technical writer may include creating how-to guides, instruction manuals, FAQ pages, journal articles, and other technical content that can aid the user understanding. The ultimate goal is to enable the user to understand and navigate a new product or concept without difficulty.",
+    "links": []
+  },
+  "ZRGsokU313Ky-anWbWK6q": {
+    "title": "Who is a Technical Writer?",
+    "description": "A **Technical Writer** is a professional communicator whose role is focused on creating, updating, and managing technical documentation, instructional manuals, how-to guides, and similar documents. These professionals have the skillset to translate complex technical information into simplified terms that can be easily understood. Technical writers often work closely with software engineers, project managers, system analysts, and other technical experts to gather information. They can be found across a wide range of industries, including IT, engineering, scientific research, medical, and others. The ultimate aim of a technical writer is to enable the end-users, whether they are customers, employees, or any stakeholders, to comprehend and use a product or service effortlessly.",
+    "links": [
+      {
+        "title": "What Is a Technical Writer?",
+        "url": "https://boffin.education/introduction-to-technical-writing/#2-what-is-a-technical-writer",
+        "type": "article"
+      },
+      {
+        "title": "A Day in the Life of a Technical Writer",
+        "url": "https://boffin.education/technical-writing-roles-and-responsibilities/#4-a-day-in-the-life-of-a-technical-writer",
+        "type": "article"
+      },
+      {
+        "title": "Glossary of Technical Writing Terms: \"Technical Writer\"",
+        "url": "https://boffin.education/glossary-of-technical-writing-terms/#technical-writer",
+        "type": "article"
+      }
+    ]
+  },
+  "jl1FsQ5-WGKeFyaILNt_p": {
+    "title": "What is Technical Writing?",
+    "description": "Technical writing involves explaining complex concepts in a simple, easy-to-understand language to a specific audience. This form of writing is commonly utilized in fields such as engineering, computer hardware and software, finance, consumer electronics, and biotechnology.\n\nThe primary objective of a technical writer is to simplify complicated information and present it in a clear and concise manner. The duties of a technical writer may include creating how-to guides, instruction manuals, FAQ pages, journal articles, and other technical content that can aid the user's understanding.\n\nTechnical writing prioritizes clear and consistent communication, using straightforward language and maintaining a uniform writing style to prevent confusion. Technical writers often integrate visual aids and leverage documentation tools to achieve these objectives.\n\nThe ultimate goal is to enable the user to understand and navigate a new product or concept without difficulty.",
+    "links": []
+  },
+  "j69erqfosSZMDlmKcnnn0": {
+    "title": "Role of Technical Writers inOrganizations",
+    "description": "The role of a **Technical Writer** is primarily to translate complex technical information into simpler language that is easy to understand for a non-technical audience. They design, write, edit, and rewrite technical pieces like operating instructions, FAQs, installation guides, and more. Apart from this, they also gather and disseminate technical information among customers, designers, and manufacturers. Essentially, their job involves communicating technical terminologies and a clear understanding of complex information to those who need it in an easy-to-understand format.",
+    "links": []
+  },
+  "cNeT1dJDfgn0ndPzSxhSL": {
+    "title": "Forms of Technical Writing",
+    "description": "These can range from user manuals, how-to guides, white papers, design specifications, and project plans, among others. Each form serves a different purpose and audience. For instance, user manuals are typically directed towards end users, providing step-by-step instructions on how to use a particular product. On the other hand, design specifications target developers or technical teams, detailing how a certain technology or product should be designed or built. These various forms highlight the breadth and diversity of output that a technical writer can create. It's essential for a technical writer to understand the distinctions and appropriate usage of these forms to effectively communicate technical information.",
+    "links": []
+  },
+  "FVxNjbDBxgf6vkZWw1Awt": {
+    "title": "Growth as a Technical Writer",
+    "description": "The growth phase in the field of technical writing is intriguing. As a technical writer gains experience and demonstrates excellent work consistently, they are likely to encounter many opportunities for growth. This can include taking on more complex projects, managing teams, or even moving toward strategic roles. Career advancement may involve specializing in specific industries or gaining fluency in cutting-edge tools and formats. Technical writers may also grow by expanding their skill set to encompass related fields like data analysis, UX writing, content management, or project coordination.",
+    "links": []
+  },
+  "8rjUZ9NZPGwVRGmk6Dlyb": {
+    "title": "Required Skills",
+    "description": "Here are Core Skills required to become a proficient **Technical Writer**:\n\n1.  **Writing Skills**: Excellent grasp over language and grammar, superior spelling ability, and an understanding of punctuation are essential for a technical writer.\n    \n2.  **Technical Expertise**: They should have a good understanding of complex technical concepts and translate them into understandable content.\n    \n3.  **Research Skills**: Identifying the needs of the end-user, and the ability to quickly understand new concepts and technologies.\n    \n4.  **Tools Proficiency**: Technical writers must be proficient in various communication and publishing tools like Microsoft word, Google Docs, Adobe Acrobat, and Photoshop, etc.\n    \n5.  **Design skills**: Understanding of basics of layout and design is a huge plus for technical writers.\n    \n6.  **Attention to Detail**: They should be detail-oriented to create clean, high-quality content.\n    \n7.  **Organization Skills**: They should have the ability to manage multiple projects and consistently meet deadlines.",
+    "links": []
+  },
+  "DubLTESNn3wvEH_bKQZbP": {
+    "title": "Technology Expertise",
+    "description": "**Tech Expertise**: The technical expertise of a technical writer mainly refers to their understanding of the technology or the topic they are writing about. It encompasses their ability to efficiently understand complex technical processes, terminologies, and products, and translate them into simpler, more understandable language. This understanding might be based on their formal education in technical disciplines, personal interest, or gained experience in the industry. It's worth noting that tech expertise is not about being a subject matter expert on every technical field, but rather having the skills to comprehend and interpret information accurately. It involves the use of various software tools, Research and Development (R&D), and sometimes coding. This proficiency allows technical writers to create thorough, accurate, user-friendly documents and manuals.",
+    "links": []
+  },
+  "kNIiAJrvrNoOAllUbRtUB": {
+    "title": "Language Proficiency",
+    "description": "\"Language Proficiency\" is extensively required in the area of technical writing. This skill involves having an exceptional command over the language that the technical document is being written in. This includes not just general fluency, but also understanding the intricacies of grammar, semantics, syntax, and vocabulary. In particular, a technical writer should be able to explain complex ideas using simple and accessible language. This helps in enhancing the clarity and effectiveness of the technical documents being produced. It's also beneficial to be familiar with the terms and phrasing commonly used in the specific industry or field that the technical documentation pertains to.",
+    "links": []
+  },
+  "7-3tqRUpntoQP4nK_nul5": {
+    "title": "Written Communication Proficiency",
+    "description": "Written communication is a critical asset in a technical writer's skill set. This skill is not just about having a good command of grammar and vocabulary, but also the ability to convey complex information in an understandable, clear and concise manner. A proficient technical writer should know how to structure their content appropriately, maintain a consistent tone and voice, and use illustrative examples to make the concepts more relatable for the audience. Accuracy is essential in written communication as technical writing often involves descriptions of intricate processes or use-cases where there is no margin for error. Understanding the nuances of different writing styles and adapting to the intended audience's comprehension level are also a part of effective written communication.",
+    "links": []
+  },
+  "_5xFbl2BHx0f2u9HmSVS8": {
+    "title": "Tooling",
+    "description": "In the realm of technical writing, \"tooling\" refers to the various software and applications technical writers utilize to create, manage, and publish high-quality technical documentation. This can include word processors, desktop publishing apps, XML editors, content management systems, and many more. Some popular examples of tools used by technical writers include Microsoft Word, Google Docs, Adobe FrameMaker, MadCap Flare, Markdown, GitHub, and Jira. These tools enhance productivity by allowing for document versioning, enabling collaboration, offering templates for consistent formatting, providing features for managing large amounts of content, and even offering functionality for translating documentation into multiple languages. The choice of tools depends on the specific needs and workflow of the technical writer or the organization they are working for.",
+    "links": []
+  },
+  "jC3ZrpskBqzxiV6SKf4Uf": {
+    "title": "Publishing Tools",
+    "description": "When discussing the realm of tooling in technical writing, publishing plays a significant role. It involves the final process of making the documentation accessible to users. There are various tools used for publishing like Adobe FrameMaker, MadCap Flare, Jekyll, etc, which support different formats like PDF, HTML, ePubs, etc. They could also include features for version control, collaboration, and content reuse. This not only makes the content accessible to the users but also ensures that the documentation is kept consistent and up-to-date.",
+    "links": []
+  },
+  "cSZbTOB0FPPOlGzy-MkSi": {
+    "title": "Plagiarism Checker",
+    "description": "**Plagiarism** refers to the act of copying someone else's work, ideas, or expressions and presenting them as your own without giving due credit to the original author. This unoriginal practice is seen as theft of intellectual property and can incur serious repercussions in both academic and professional settings. In the case of technical writing, using specialized plagiarism detection softwares is crucial to ensure the originality and authenticity of the content. Some of these detection tools include Turnitin, Grammarly, Copyscape, and many more. They work by cross-referencing your work with a vast database of academic and professional documents to identify any matching phrases that could constitute plagiarism.",
+    "links": []
+  },
+  "Am_ocP3r0HM45LYfMcQxM": {
+    "title": "Editing Tools",
+    "description": "### Editing\n\nEditing refers to the process of reviewing and correcting written material to improve accuracy, readability, and fitness for its purpose, and to ensure that it is free of error, omission, inconsistency, and repetition. In the context of technical writing, effective editing is essential for producing high quality content. This involves checking the document for grammatical errors, punctuation errors, and spelling errors. It also includes checking for factual correctness, logical flow, and coherency. There are several tools available for editing such as Grammarly, Hemingway App, and ProWritingAid, among others. These tools aid the technical writer in the editing process by providing features such as grammar checking, spell checking, and feedback on writing style.",
+    "links": []
+  },
+  "ffJyulu9GPB_TDqjeJYyV": {
+    "title": "Git / Version Control",
+    "description": "Git is a free and open-source distributed version control system, designed to handle everything from small to very large projects with speed and efficiency. It is easy to learn and has a tiny footprint with lightning-fast performance. Git allows and encourages you to have multiple local branches that can be entirely independent of each other. The creation, merging, and deletion of those lines of development take seconds. It also provides strong support for non-linear development, numerous workflows, and robust features such as strong cryptographic authenticity of history.",
+    "links": []
+  },
+  "TJ1iuzQ9u_WbrllRQkgm_": {
+    "title": "Markdown",
+    "description": "Markdown is a lightweight markup language with plain-text-formatting syntax. It was created by John Gruber, with significant contributions from Aaron Swartz, with the goal of allowing people \"to write using an easy-to-read, easy-to-write plain text format\". Key features include automatic production of well-structured, ready-to-publish documents from 'readable' text files. Its syntax includes items like headers (`# Header`), bullet lists (`- item`), italics (`*text*`), bold (`**text**`), links (`[description](url)`) and so forth. Markdown files usually end with `.md` or `.markdown`.",
+    "links": []
+  },
+  "0XWiraeoicNBbaGYQnNZr": {
+    "title": "Research Tools",
+    "description": "In the work of a technical writer, **Research Tools** are critical, as they aid in sourcing, verifying, and organizing information needed for creating technical documents. Various specific tools are available, depending on the information you're seeking. For instance, scientific papers may be searched using **Google Scholar** or specialized databases like **PubMed**. **Semantic Scholar** can help find academic papers across many disciplines. For less formal online sources, **Google Alert** can be set up to watch for new information on a specific topic. Further, **Evernote** can be used to compile and manage information from multiple sources. For organizing and evaluating data, tools like **Microsoft Excel**, **Tableau**, or **Google Sheets** can be employed. Please remember that the choice of tool will depend on your subject, the type of information you need, and how you want to manage and present that information.",
+    "links": []
+  },
+  "sdoFe4A3y_-Zp3mlrJ5r8": {
+    "title": "Blogging Platforms",
+    "description": "\"Blogging Platforms\" refers to software services that allow users to create, post, and manage blogs online. Some well-known examples of blogging platforms include WordPress, Blogger, Tumblr, and Medium. These platforms often feature user-friendly interfaces and offer various customization tools to suit your blogging needs. WordPress, for instance, offers significant flexibility and a wide range of themes and plugins, while Blogger is known for its reliable Google integration. Tumblr's social sharing functionality makes it a prominent choice among creative bloggers, and Medium is noted for its emphasis on high-quality content and its user-friendly editor. [Dev.to](http://Dev.to), Hashnode and Hackernoon are free, beginner-friendly blogging platforms that cater to developers, and allow them to share ideas with each other. Each platform offers different strengths depending on your particular needs and specialization as a technical writer.",
+    "links": []
+  },
+  "FD-8LQ_g2_O_i2Qwp-Gpv": {
+    "title": "SEO Tools",
+    "description": "SEO tools are critical for any technical writer as they help streamline the process of optimizing content for search engines. There is a wide variety of these tools available in the market, some of the most popular ones being Google Analytics, SEMRush, Moz, and Ahrefs. These tools provide different functionalities such as keyword research, backlink analysis, and website audits. They can work as stand-alone tools or be integrated within content management systems for seamless functioning. Remember though, while these tools assist in SEO, effective optimization still largely depends on quality content and strategic planning.",
+    "links": []
+  },
+  "yYLsG2LuPaNUuhXSVev_0": {
+    "title": "Best Practices",
+    "description": "As a technical writer, adhering to established best practices helps to ensure the consistency, clarity, and overall quality of your work. Some common best practices include:\n\n*   **Always consider the audience**: Write the content with the user's perspective in mind. Make sure the technical jargon, language, and complexity level match your intended readers.\n    \n*   **Organize the content logically**: Divide the material into sections, subsections, bulleted lists, and tables. Use headlines to help the readers navigate through the content.\n    \n*   **Use diagrams and images when necessary**: Visual aids can often enhance the understanding of a complex idea or process.\n    \n*   **Write clear and concise sentences**: Avoid ambiguous information and jargon that the reader may not understand. Always aim for readability.\n    \n*   **Edit, edit, edit**: Proofread your work, correct grammar and spelling errors, and ensure the information is accurate and current.\n    \n\nFollowing these best practices can increase the effectiveness of your technical writing and ensure your audience understands and retains the information easily.",
+    "links": []
+  },
+  "27muFD1Ld1gF6hhIh22sG": {
+    "title": "Story Telling",
+    "description": "**Story Telling** is a powerful tool for technical writers. It allows you to communicate complex concepts and information in a more relatable and understandable way. Essentially, it revolves around presenting information as a narrative with a clear beginning, middle, and end. This entails establishing context (beginning), explaining the process or concept (middle), and summarizing the outcome, conclusion, or application of the process or concept (end). Story telling in technical writing can take various forms including business scenarios, case studies, user stories, etc. It is essential to keep your 'story' relevant, realistic, and as concise as possible. Remember, the purpose is not primarily to entertain but to educate and inform your audience while keeping them engaged.",
+    "links": []
+  },
+  "lxSSjgtqJk-PtRp4hARDw": {
+    "title": "Subtle Selling",
+    "description": "**Subtle Selling**: This is an approach in technical writing where the writer indirectly promotes or advocates for a particular product, service, or idea. Subtle selling is about providing informative, helpful content without overtly pushing a sale or marketing a product. It often involves highlighting the unique features or aspects of a product or service in the context of solving a problem or addressing a particular need, hence subtly influencing the reader to consider it. It's about clever positioning rather than overt persuasion, emphasizing the value a product or service can provide in a discreet and unobtrusive manner.",
+    "links": []
+  },
+  "Ezz2e4lYLD_bdNNwvsV_y": {
+    "title": "Content Structure",
+    "description": "Content structure in technical writing is a crucial aspect that ensures readers can follow through and understand the information seamlessly. It involves organizing content logically, creating outlines, using headings and subheadings, and writing in a linear and clear manner. Furthermore, the structure includes the application of sequences such as chronological orders, step-by-step guides, or flowcharts. The table of contents and index also play a significant role in structure, as they allow readers to navigate quickly to different areas of the document. Additionally, elements such as glossaries help to define complex terms used in the text. Ultimately, a well-structured document creates an excellent user and reading experience.",
+    "links": []
+  },
+  "a1ChwDwztjZBi79y38AGa": {
+    "title": "Call to Actions",
+    "description": "Call-to-Actions (CTAs)\n----------------------\n\nCall-to-Actions are critical components in technical writing. They primarily direct readers toward performing specific tasks or activities. Often used in manuals, guidelines, procedures, and any instructive materials, they make the content actionable. CTAs can take several forms such as, \"_Click here_\", \"_Submit a request_\", or \"_Download now_\". They should be concise, clear, and direct. Incorporating compelling verbs can make the CTA more effective. Always remember to place CTAs where readers can easily see them, and it's recommended to use a contrasting color, if possible, for a standalone CTA button to make it more noticeable.",
+    "links": []
+  },
+  "8qSL2esjsA3YYuB4d7B9z": {
+    "title": "References",
+    "description": "References are an essential part of any technical document. They provide a means to verify the information you have given, adding credibility to your work. Cite sources from where you gather your data, facts or figures. According to the style of writing you are using, you may be required to provide in-text citations or footnotes. Also, there are various formats for creating a reference list or bibliography at the end of your document. Examples of some commonly used formats include APA, MLA, and Chicago. Always make sure that your references are relevant, current, and correctly cited to avoid plagiarism. The number of references may vary based on the type, length, and complexity of the technical document.",
+    "links": []
+  },
+  "WmOvQYlnedX0QgC5Adeen": {
+    "title": "Crafting Great Titles",
+    "description": "Creating great titles is an essential best practice for technical writers. Titles should be engaging, accurate, clear, concise, and should provide a quick summary of what your article or document is all about. They should include keywords relevant to your content, but avoid jargon that could alienate your readers. Use active verbs instead of passive wherever possible to give your titles more impact. Also, make sure that your title doesn't promise something that the content doesn't deliver. Consider your audience and what would be most valuable and informative to them. Finally, always review and revise your titles as needed.",
+    "links": []
+  },
+  "7FGMPztd6ouvqemcGhIol": {
+    "title": "Content Objectives & Intent",
+    "description": "Content objectives refer to the identified goals or targets that a technical writer aims to fulfill with a piece of content. Often, these goals are aligned with the overall project aims and may include educating users, providing clear instructions, or explaining a specific topic in a digestible format. It is important for technical writers to define their content objectives clearly, in order to tailor their writing approach, style, and structure accordingly. Moreover, content objectives serve as a guide in creating, reviewing, and revising the content to ensure that it meets the intended purpose. Therefore, content objectives serve as the underlying basis, which significantly influences the quality of the final content output.",
+    "links": []
+  },
+  "UuV51vM2JT_LFFXORSwru": {
+    "title": "User Persona",
+    "description": "User Persona is a significant and efficient tool used by technical writers to address their audience effectively. It is a fictional character, a typical member of the target audience who is characterized by behavior patterns, goals, skills, attitudes, etc. The persona is built based on the data about real users. It serves to help technical writers visualize the audience, understand their needs and expectations, ensure that the content is clearly understood, and enhance the overall readability. User Personas allow writers to design effective communication strategies and create more user-centered documentation, making information easy to find, understand, and use.",
+    "links": []
+  },
+  "cnEVPsqZqs9ZdyqmOuLGA": {
+    "title": "Writing Style Guides",
+    "description": "As a technical writer, creating a **writing guide** is essential to ensure consistency and quality in all documents you create. A writing guide can entail a set of rules about the style, tone, terminology, syntax, punctuation, and lexicon in your text. This should aid in maintaining a uniform approach to your writing, which is vital when dealing with technical information. Your writing guide will depend on the project requirements and preferences of your target audience, and it needs to be easily understood and followed by anyone involved in the project. Additionally, your guide may also include procedures on how to incorporate images, links, or other similar elements in your text. Importantly, make sure to keep updating your guide as you gain more knowledge and skills in technical writing.",
+    "links": []
+  },
+  "O-dZEkmU0tP3dUIUPM6YJ": {
+    "title": "Content Research",
+    "description": "`Content research` involves a systematic investigation into a specific subject matter in order to gather reliable and relevant information. This process is crucial for a technical writer as it helps in generating valuable content that's accurate, informative, and engaging. It goes beyond basic internet search; it includes reading technical documents, interviewing experts, conducting surveys, and analyzing data. Content research should be conducted in a strategic manner, taking into consideration the purpose of the information, the target audience, and the key message to be conveyed. A well-executed content research process helps technical writers produce high-quality content that's both clear and concise.",
+    "links": []
+  },
+  "SX4vL_JEHrwqHdThyqKKO": {
+    "title": "Topic Score",
+    "description": "`Topic Score` is a computational study that calculates how well a particular content piece covers a specified topic. Usually measured on a scale of 0 to 100, it uses different metrics such as keyword usage, semantic relevance, depth of topic coverage, among others. The higher the topic score, the more comprehensively your content is considered to cover the targeted topic. It can be beneficial for content strategists and technical writers to focus on target keywords in order to improve overall content quality and boost SEO performance.",
+    "links": []
+  },
+  "JtFLW5WwH5Ixmnb0qikia": {
+    "title": "Keyword Volume",
+    "description": "`Keyword volume`, also referred to as `search volume` or `keyword search volume`, is a metric that reflects the number of times a specific keyword was searched for in a search engine (like Google) within a specified timeframe. This data is typically monthly but can be analyzed over different time periods. A higher keyword volume means that more people are searching for that particular term. SEO tools like Google Keyword Planner, SEMrush, or Ahrefs can be used to find the volume of keywords. Note that keyword volume doesn't assess the quality of a keyword, it only measures popularity.",
+    "links": []
+  },
+  "QMehC1tmWPVWaTsiV9sFC": {
+    "title": "Communities & Forums",
+    "description": "Forums can be essential sources of information for a technical writer during the content research process. These are online platforms where people discuss different types of subjects. Often, they are used to ask questions, answer queries, or share ideas about a particular topic. Examples of forums include \"Reddit\", \"Quora\", or specialized tech forums like \"Stack Exchange\". These sites allow a technical writer to learn about common issues, troubleshoot problems, comprehend user experiences, and stay updated with the latest trends or changes in a specific field. Depending on the industry or field you're writing for, there are different niche forums you can explore. Always make sure to cross-check the information you find on forums as it can vary in reliability.",
+    "links": []
+  },
+  "IZqyEqkrBoEfLBwIQwJl6": {
+    "title": "Search Trends",
+    "description": "\"Search Trends\" refers to the analysis of the patterns, fluctuations, and shifts in the popularity of specific search terms over a given period. This data-driven approach can be leveraged to identify the trending topics or keywords among users, often within specific regions and contexts. Google Trends is a common platform for examining these trends, providing ample insights into the most recent or popular search queries. Utilizing search trends can allow technical writers to keep their content resonating with their audience by incorporating the latest or topical keywords, resulting in improved content visibility and relevancy.",
+    "links": []
+  },
+  "xFMsHYYxC0hLueY9xxART": {
+    "title": "Support Request Evaluation",
+    "description": "`Request Evaluation` in the context of a technical writer refers to the process of assessing or defining the requirements and the scope of a given writing project. It includes assessing information sources, understanding the objectives of the document, defining the target audience, understanding regulatory specifications if any, and considering the timelines and deadlines. This stage is critical in giving the writer a comprehensive understanding of what is expected from the project, thereby equipping them to structure an efficient content strategy.",
+    "links": []
+  },
+  "xV8mox1WnSbl2jAGqQpeg": {
+    "title": "Types of Technical Content",
+    "description": "There are several types of technical writing, each focused on different aspects. **End-user documentation writers** specialize in creating materials for product users (like user manuals and quick start guides). **Traditional technical writers** draft articles, FAQs, guides, and other content primarily for websites. **API/SDK writers** are responsible for creating and maintaining documentation for application programming interfaces (Software Development Kits), which requires knowledge of multiple programming languages. **Medical writers** work in the medical sector and must understand medical concepts. **Grant and proposal writers** are essential for organizations obtaining funds for projects. Note that these are not all mutually exclusive; many technical writers span multiple categories.",
+    "links": []
+  },
+  "d9mTdwqx6QWKYO5PA_rDH": {
+    "title": "Product Content",
+    "description": "**Product Content** is a significant type of technical writing which pertains to any information about a product, usable for consumer guidance. This includes user manuals, installation guides, frequently asked questions (FAQs), product descriptions, and software application interfaces. Product content not only involves detailing how a product works but also providing information about dealing with potential issues. The aim of this type of technical writing is to simplify complex concepts and instructions relevant to the product to help users understand its functionalities as easily as possible. This area of technical writing requires accuracy, clarity, simplicity, and thorough research about the product.",
+    "links": []
+  },
+  "UFuMiHtWq1M8dS8547lOp": {
+    "title": "General Product Prose",
+    "description": "**Product Prose** is a form of technical writing focused on explaining how a particular product works, its features, and how it can be beneficial to users. This type of technical writing usually takes the form of user guides, product manuals, and online help systems. It's generally written in a simple, understandable language and employs diagrams, images, and screenshots for better understanding. The aim of product prose is to assist users in utilizing the product effectively and resolving any issues that may arise during its use. A product prose writer must possess an in-depth understanding of the product, strong communication skills, and the ability to write clear, concise instructions.",
+    "links": []
+  },
+  "C-eVVtF6Yabp2a6XvMeh_": {
+    "title": "How-to Guides",
+    "description": "\"How to Guides\" is a type of technical writing that prioritizes instructive, step-by-step information. Typically, these guides are designed to help the reader understand how to perform a specific task or process. They may depend on clear written instructions, accompanied by visuals like diagrams or screenshots. This format ensures in-depth accuracy and demonstrates each phase of the process explicitly. Examples of \"how to guides\" can range from software user manuals, product assembly instructions, tutorial blog posts, to recipe instructions. These guides thrive on simplicity, targeting a wide audience including both professionals and novices.",
+    "links": []
+  },
+  "e8oNoXw1KLY4jDzojIXyk": {
+    "title": "Developer Docs",
+    "description": "Developer docs, also known as developer documentation or API documentation, is a form of technical writing specifically aimed towards software developers. This type of documentation usually includes technical specifications of APIs, code comments, software design and architecture, and other detailed technical descriptions involved in software development. Developer docs are essential tools for developers as they provide the necessary guidelines, standards, and examples for using and integrating specific software, libraries, or APIs. The structure and comprehensiveness of developer docs can vary greatly depending on the complexity of the software it describes, but the main purpose is to help developers understand, utilize, and contribute to the software efficiently.",
+    "links": []
+  },
+  "FgyBWRtE34VNqBt_5QhAf": {
+    "title": "User Goals",
+    "description": "User Goals\n----------\n\nUser goals pertain to the actions that a user wants to perform or the outcomes they hope to achieve with a certain product or service. For technical writers in the context of developer docs, understanding user goals is critical as it drives the creation of accurate, relevant, and effective documentation. Whether it's installing a software, using an API, debugging an issue, or learning advanced functionalities, these goals should guide all aspects of document planning and writing. It is essential to isolate these goals through user feedback, surveys, or usability testing to produce documentation that improves user-product interaction and problem-solving processes, making users more self-sufficient. From a developer's perspective, user goals may involve tasks related to code implementation, product integration, problem troubleshooting, and more.",
+    "links": []
+  },
+  "2pNW7wDGih_m73lhGZRg6": {
+    "title": "Developer Journey",
+    "description": "Developer Journey\n-----------------\n\nThe term \"developer journey\" usually refers to the full spectrum of experiences a developer goes through - from learning about a system or tool for the first time, to getting set up, to building or integrating applications with it. This journey typically involves a series of phases including initial discovery, setup and installation, first use, ongoing development, troubleshooting and optimisation. Developer docs play an integral role in this journey, providing necessary instruction and guidance at each step. Recognising key stages in the developer journey can help guide the design and organisation of developer docs, ensuring they deliver pertinent, useful content that enhances the overall developer experience.",
+    "links": []
+  },
+  "jYhfx6RETFgDulyNqdTBy": {
+    "title": "Docs Structure",
+    "description": "The **documentation structure** refers to the arrangement and organization of information within the documentation. It should offer an intuitive and logical user navigation to facilitate quick comprehension and locate vital information effortlessly. The structure usually includes sections such as **Overview**, explaining the product and its issues it solves. **Getting Started** or **Quick Start Guide** offers initial information about using a product right away. **Tutorials** provide a step-by-step guide to completing a particular task. **How-to guides** solve a problem or accomplish specific user goals. **Concept guides** offer deeper understanding about the product's functionality while **API/SDK Documentation** contains code-based information. Lastly, **Reference Manuals** or **User guides** provide comprehensive details of the product’s functionality. The structure may vary depending on the type of product/service.",
+    "links": []
+  },
+  "z5_73Q7dWbBd4m_OrdZlH": {
+    "title": "API Reference",
+    "description": "API References are comprehensive guides designed to understand the details of the API. Usually, they include information such as endpoints, request examples, response types and examples, and error codes. API References help developers learn the specifics of your API’s endpoints and understand how to successfully integrate the API into their software.\n\n    **API References**\n    API References offer in-depth information about the functionalities of APIs. Details such as `endpoints`, `request examples`, `response types`, `response examples`, and `error codes` are thoroughly enumerated. They are made to assist developers in understanding the intricate workings of the API, allowing them to incorporate the API seamlessly into their software.",
+    "links": []
+  },
+  "iBBeZopD8SNo7sWTohMim": {
+    "title": "Docs Generation Tools",
+    "description": "API documentation generation tools are software applications that create API documentation directly from the source code. This streamlines the process for developers and also ensures that the documentation stays updated with the code changes. Examples of these tools include Doxygen, Sphinx, Javadoc, Swagger UI, and Slate. Doxygen works with several programming languages including C++, Python, and Java. Sphinx is often used for Python. Javadoc is specifically for Java code. Swagger UI lets you visually interact with your API’s resources without having any of the implementation logic in place. Slate generates static HTML that looks great, is responsive, and can be easily hosted on sites like Github.",
+    "links": []
+  },
+  "co-35BsWMrD6PXohpFqba": {
+    "title": "API Definitions",
+    "description": "API stands for Application Programming Interface. Essentially, it's a set of rules and protocols for building and integrating application software. APIs allow different software programs to communicate with each other, acting as a bridge between them. They define the kinds of calls or requests that can be made between applications, how to make them, the data formats that should be used, and the conventions to follow. APIs can be used for web-based services, operating systems, databases, or software libraries. They are designed to provide a consistent experience, simplify programming, and support modularity and scalability. APIs often come in the form of a library that includes specifications for routines, data structures, object classes, and protocols used to communicate between the consumer and the provider of the API.",
+    "links": []
+  },
+  "e_bsYrZ0eQqduURg2ybX4": {
+    "title": "Help Content",
+    "description": "\"Help Content\" refers to a variety of resources specifically designed to provide users with detailed information, assistance, and troubleshooting advice for software products, hardware devices, or complex services. This includes guides, FAQs, how-to articles, and video tutorials. Help content should be easily accessible, clear, concise, and focused on helping the end-user to perform specific tasks effectively or resolve issues independently. The complexity and depth of the help content may vary based on the target audience's technical expertise and familiarity with the product or service.",
+    "links": []
+  },
+  "8fJcJi96Ige6z2PBuTquC": {
+    "title": "Troubleshooting",
+    "description": "Troubleshooting is a vital aspect of help content where the technical writer provides solutions to potential problems end-users might encounter while using a product or a service. Typically formatted as a step-by-step guide, troubleshooting guides aren’t necessarily there to fix the issue immediately but to identify what course of action to take in case of certain problems. Clear, precise, and easy-to-follow, these guides should cover common software issues, hardware malfunctions, or system errors, significantly improving user experience and reducing the need for support service contacts.",
+    "links": []
+  },
+  "7w1SjK-LV9SBZJ673eAUd": {
+    "title": "Developer Support",
+    "description": "\"Support content\" is another critical aspect of technical writing. It is the material that assists users in troubleshooting issues, understanding complex topics, or learning how to use a product or service independently. An integral part of user assistance, support content often takes the form of FAQs, tutorial articles, video demonstrations, manuals, or help guides. It caters to the end-users' immediate and long-term needs, helping them navigate and maximize the use of a product or service. For example, if a user encounters a problem using a software, instead of reaching out to technical support, they might refer to support content, such as a how-to guide or an instructional video, to resolve the issue independently. Clear, easy-to-follow, and accessible support content significantly enhances user experience and satisfaction.",
+    "links": []
+  },
+  "How-4Re1NhxPLDoshUM-G": {
+    "title": "Platform Support",
+    "description": "The **Support Manual** is a comprehensive document that details the use and maintenance of a product or service. It's intended to guide users while troubleshooting or strategizing for optimal use. Inside a support manual, you'll often find a product or service overview, step-by-step instructions for various procedures, a troubleshooting section to resolve common issues, and a list of contacts for more in-depth support. Each part is written clearly and concisely, with simplified language and visuals when necessary, to ensure that users of varying levels of expertise can effectively understand and apply the guidelines.",
+    "links": []
+  },
+  "mJ1s5-SGd_tj8y0LLZxYg": {
+    "title": "Technical Content Marketing",
+    "description": "`Marketing` is a business strategy which involves identifying customer needs and determining how best to meet those needs. In other words, it is about ensuring that a business or product is positioned in such a way that it will attract the desired audience, encouraging them to buy in. This strategy comprises multiple aspects including `market research`, `branding`, `product development`, `sales`, `promotion`, and `public relations`. Marketers use these tactics to create a company image, build customer relationships, attract potential customers and retain existing ones. The ultimate aim of marketing is to boost sales and help the business grow.",
+    "links": []
+  },
+  "O1apL6I_g9DQl8VbL3X4W": {
+    "title": "ICP & Buyer Persona",
+    "description": "The **ICP (Ideal Customer Profile)** and **Buyer Persona** are key concepts in marketing and sales. The **ICP** refers to a hypothetical company which perfectly meets the selling organization's product/service. It's a detailed description of their ideal target company, taking into account factors such as industry, size, budget, pain points, needs, and challenges. On the other hand, a **Buyer Persona** is a semi-fictional representation of your ideal customer, often based on market research and real data about existing customers. While ICP targets companies as a whole, a buyer persona focuses on individuals, giving insights into customer behaviors, goals, skills, attitudes, and demographic information. Both constructs help tailor marketing efforts to attract the right audience and convert them into customers.",
+    "links": []
+  },
+  "EhhKxYPtoLztZXBXl3ZGl": {
+    "title": "Buyer Journey & Content Funnel",
+    "description": "The **Buyer Journey** refers to the process a customer goes through from the moment they become aware of a need or desire until the point of purchase. It is often categorized into three main stages: Awareness, Consideration, and Decision. In the _Awareness_ stage, the customer realizes they have a problem or need. During the _Consideration_ stage, they evaluate different options to satisfy that need. Finally, in the _Decision_ stage, they choose a specific solution. Understanding the buyer journey is instrumental for businesses, as it helps them tailor their marketing strategies to the right audience at the right time.",
+    "links": []
+  },
+  "-IBL9S4DelIi07w_fmrX3": {
+    "title": "Content SEO",
+    "description": "\"SEO\" stands for \"Search Engine Optimization\". It is a digital marketing strategy focused on boosting the online visibility of a website or a web page in a search engine's unpaid results. Typically, the higher ranked on the search results page or more frequently a site appears in the search results list, the more visitors it will receive from the search engine's users. SEO tactics can target various types of search like image search, local search, video search, academic search, news search and industry-specific vertical search engines. It involves a range of activities such as keyword research and optimization, link building, and content creation, geared towards making a site more attractive to search engines. Beyond assisting with visibility, SEO also helps to improve the user experience and usability of a website.",
+    "links": []
+  },
+  "UphVii3y4T_PkRMqFJ4r_": {
+    "title": "Backlinking",
+    "description": "Backlinking, often referred as \"inbound links\" or \"incoming links\", is a method used in search engine optimization (SEO) where other websites link to your content. Backlinks are significant indicators of content's relevance, quality, and credibility to search engines. Achieving backlinks can be a result of great content naturally earning shares, or a strategic move of reaching out to relevant websites, guest posting, or engaging in content promotion. The more high-quality backlinks your website obtains, the more likely it is to rank well in search engine results. However, it's also crucial to consider where your backlinks originate from, as links from spam or low-quality websites can potentially harm your ranking. In addition, Google values various backlink parameters like anchor text distribution, dofollow and nofollow ratio, and link acquisition rate while evaluating a website.",
+    "links": []
+  },
+  "eAioe6b7w8pV2Dvawl_fw": {
+    "title": "Short-tail Keywords",
+    "description": "\"Short Tail Keywords\" are concise search phrases, typically containing one or two words. They bear a broad search intent due to their general nature and high search volume. An example might be a keyword as simple as 'Shoes'. It poses an immense search intent possibility ranging from the need to buy shoes to finding shoe repair services. Short tail keywords are incredibly competitive in SEO, often dominated by large and well-established corporations, making it harder for smaller businesses or new websites to rank for these terms.",
+    "links": []
+  },
+  "2LAvq7W11WMIubSprlK_l": {
+    "title": "Long-Tail Keywords",
+    "description": "Long Tail Keywords are more specific keyword phrases usually three to four words long that your audience might be searching for when they're closer to needing your products or services. They're a bit counter-intuitive, at first, but they can be incredibly useful if you understand their potential. With long-tail keywords, you can reach a more targeted audience that is typically further along in the buying cycle. They are less competitive than more common \"head\" keywords, and often have a higher conversion rate because they can better match with the specific services or products your business offers.",
+    "links": []
+  },
+  "IA6TuXmOZr_-Y3HLHqxp0": {
+    "title": "SEO Keywords",
+    "description": "\"SEO Keywords\" are the words and phrases in your web content that allow people to find your site via search engines such as Google. When used effectively, they can dramatically increase the visibility of your content, making it easier for those who are looking for information on your topic to find you. Used in titles, subheadings, meta descriptions, image descriptions, URL structures, and throughout the webinar, these keywords make it evident what the content is about. For maximizing effectivity, the SEO Keyword should align closely with the content topic, be relevant to your target audience, and be phrases that people commonly search for. An important aspect to note is that keyword stuffing, the practice of overloading content with keywords in an unnatural manner, is heavily penalized by search engines. Keywords usage should be strategic and the content should always prioritize providing value to the reader.",
+    "links": []
+  },
+  "5dnZe0oCIzb5qGwgI6pwH": {
+    "title": "Top-funnel Content",
+    "description": "\"Top funnel\" refers to the awareness stage of a customer's journey, where they first come into contact with a business or product. In this stage, they become aware of a problem they have and begin to search for information or solutions. Content at this stage aims to capture the attention and interest of potential customers by offering solutions or valuable information that relates to their problem. This content is typically broad and informative, rather than product-specific. The aim is to inform and educate the audience, while establishing trust and brand authority.",
+    "links": []
+  },
+  "wBDjGa2PgdmeXxHnILFjY": {
+    "title": "Pillar Content",
+    "description": "\"Pillar content\" is a comprehensive piece of content on a specific topic or theme that can be broken down into many smaller related sections. This could range from an extensive blog post, to an e-book or a guide. The main intention of creating pillar content is to share highly valuable and in-depth information about a particular subject. It forms the core or the 'pillar' of your content strategy. Supporting contents or 'cluster contents', which are essentially various sub-topics related to the pillar content, link back to this main pillar, creating a content cluster. These cluster content pieces can be blog posts, podcasts, infographics, or videos, etc., which keep your audience engaged and drives them back to your pillar content. Pillar content not only positions you as an authority in your field but also improves your SEO rankings.",
+    "links": []
+  },
+  "7S2lymeBZSMBZSsmei7us": {
+    "title": "Awareness Blog Posts",
+    "description": "\"Awareness blogs\" is a commonly used term in digital marketing, particularly concerning \"top funnel\" strategies. As the phrase implies, these blogs are designed to create, increase, or maintain awareness of a particular topic, issue, or brand. These articles typically contain knowledgeable content that highlights key information and facts, often aiming to educate the reader and provide value. The goal isn't to hard sell a product or service, but rather to softly introduce what the business, product, or service is about. As a technical writer, you may be asked to write these types of posts to raise awareness of a brand, product, service, or concept, aiming at attracting potential customers and maintaining the engagement of existing ones.",
+    "links": []
+  },
+  "HoNQSWy82ybT0YmejCzRb": {
+    "title": "Research Reports",
+    "description": "Research reports are comprehensive documents that encompass a detailed study, investigation, or analysis carried out on a particular subject. They are used to understand a specific research problem by collecting and presenting sufficient evidence to provide solutions. These reports can be prepared by organisations, research institutions, or individuals in the field of study. They are used to understand industry trends, demographic data, market activity, and competition. They can also be used to analyze a hypothesis, prove a point, or provide insightful conclusions for a particular issue or topic. Research reports are essential resources for technical writers as they provide the necessary background and context to communicate complex technical information effectively.",
+    "links": []
+  },
+  "Q2KD70IKwBXAH3UQgeZpp": {
+    "title": "Mid-funnel Content",
+    "description": "\"Mid Funnel\" refers to the phase in the marketing funnel where the consumer has moved beyond initial awareness and is now considering various options. At this stage, potential buyers are evaluating the information and comparing solutions. It is the job of a technical writer to provide content, such as case studies, webinars, whitepapers, demonstrative videos, etc., that helps guide the consumer towards choosing their solution. Technical writers must provide accurate information, uphold the brand's integrity, and position the product or service as a solution that meets the potential customer's needs effectively.",
+    "links": []
+  },
+  "XDX2QxMUkUok2fcS3tFki": {
+    "title": "Generic Gated Content",
+    "description": "\"Generic Gated\" refers to the type of content, usually informative or educational, that requires a user to provide certain information, like an email address, before gaining access to it. It's a strategy frequently used by businesses to generate leads. This can include a range of content, such as white papers, ebooks, webinars, or research reports. This strategy helps businesses capture the contact information of potential customers who scale through the top of the funnel content and have shown interest in the mid funnel \"Generic Gated\" content. These potential customers are individuals who could likely convert to customers, making them valuable leads.",
+    "links": []
+  },
+  "Xa7yBWcbP2aPs4u0C4cLJ": {
+    "title": "White-papers",
+    "description": "White papers are authoritative reports or guides that help readers comprehend an issue, solve a problem, or make a decision. As a technical writer, crafting white papers comprise primarily of intricately marrying data with insightful commentary. These documents are usually more detailed and lengthier than blogs or articles, often extending to multiple pages. They have a formal tone, due to their informational and problem-solving nature, and they may include graphs, charts, or other visual aids to help explain the information presented, along with a detailed methodology and analysis.",
+    "links": []
+  },
+  "5zQpravkqwafvwXVOuNPX": {
+    "title": "eBook",
+    "description": "`Ebooks` are longer-form content that allows a business or individual to delve deeper into a specific subject matter. They typically range from 10 to 100 pages and offer more comprehensive content than a blog post or an infographic. An ebook might consist of a multitude of different components, like a table of contents, chapters, headers, body content, and images. Despite their length, they should be designed for easy reading, considering they are usually downloaded and read on a customer’s own time. They work especially well for technical subjects that need more in-depth explanations, diagrams, or step-by-step guides for understanding the topic effectively. Because they are more substantial, they are usually gated - this means that the reader would need to provide their contact details or other information to access the download link.",
+    "links": []
+  },
+  "vo1udIIRpxNZCpA3g32F3": {
+    "title": "Bottom-funnel Content",
+    "description": "\"Bottom funnel\" refers to the final stage in the marketing funnel where potential customers are ready to make a purchase. This phase typically includes actions like negotiations, sales calls, and the final transaction. For a technical writer, understanding the \"bottom funnel\" can be crucial as it could influence the type of technical content they create. For instance, they might need to create in-depth product guides, FAQs, or troubleshooting articles that potential customers could use during the decision-making process. The main goal during the \"bottom funnel\" stage is to convince the potential customer to finalize their purchase and become an actual customer.",
+    "links": []
+  },
+  "2wjRA_pQ9cCG9Ww994FEM": {
+    "title": "Comparative Posts",
+    "description": "\"Comparative posts\" are articles that focus on comparing different products, services, or tools. In these posts, the technical writer analyzes each item's features, application, and usability, sometimes even their prices, to help clients make informed decisions. It's imperative to note, comparative posts don't just pinpoint 'which is better?'. Instead, they delve deep into the specifics of ‘why and how’ an aspect of a product or service outshines the other. This kind of technical write-up is typically unbiased, comprehensive, and objective to maintain credibility and usefulness.",
+    "links": []
+  },
+  "K459CcDrcPMJCimIcCzM6": {
+    "title": "Tutorials",
+    "description": "`Tutorials` fall under the bottom-funnel content in technical writing. They are usually step-by-step guides designed to help users achieve a specific task using a software, hardware, or system. Tutorials can take various forms, including written step-by-step instructions, annotated screenshots, videos, or even interactive modules where users can practice what they are learning in real-time. They are more hands-on and practical, often tackling real-world scenarios to ensure that users can transfer what they learn directly to their context. Tutorials are usually concise, clear and orientated towards specific tasks, this makes them accessible and user-friendly for people with varying levels of expertise.",
+    "links": []
+  },
+  "-GZXLc9RjY6eWkKC1K_Rg": {
+    "title": "Release Notes / Product Announcements",
+    "description": "Release notes, often a part of software documentation, are brief, high-level summaries provided to the users during a new release of the product. They contain vital information about the updates, including new features, enhancements, bug fixes, and often known issues of the released software version. Each release note is associated with a specific software version and aids the users in understanding what changes or improvements to expect in that particular release. An effective release note will discuss new features or enhancements in a user-focused manner, identify any action required by the user, highlight known issues and workarounds, and contain links to more detailed information if necessary. It empowers users to use the software more effectively and troubleshoot potential issues.",
+    "links": []
+  },
+  "W44q1iEj7RKM55-9jabMJ": {
+    "title": "Customer Case-Studies",
+    "description": "\"Case Studies\" are in-depth analyses often used by technical writers. They offer a detailed investigation into a specific subject, typically presenting real-world applications or scenarios. By employing a systematic approach, case studies can provide valuable insights which might not be achieved with other methods. They may contain extensive research, including interviews, observations, and data collection for quantitative and qualitative assessment. Case studies can encompass unique perspectives or complex matters, offering a rich understanding of the subject matter. They are often used in scientific, academic, and business contexts.",
+    "links": []
+  },
+  "pgrKfp1trcIxhDdvLk95g": {
+    "title": "Frequently Asked Questions",
+    "description": "\"FAQs\" stands for \"Frequently Asked Questions\". This is a crucial part of any technical document or user guide that compiles a list of common questions (with their respective answers) that users might have about a particular product, service, or topic. Good FAQs are clear, concise, and organized in a logical way. Typically, they are updated regularly based on user queries and feedback to remain helpful and relevant. FAQs can include instructions to resolve common user problems, terms and definitions, links to related resources, and other information useful for understanding and using the product or service effectively.",
+    "links": []
+  },
+  "tAFenZA0MFhMPE5cevNuD": {
+    "title": "Technical Website Copy",
+    "description": "\"Web copy\" refers to all the text content that appears on a website. This includes everything from the headlines, subheadlines, body content, call-to-action statements, product descriptions to all the metadata like the title tags and meta descriptions. The primary purpose of web copy is to communicate the site's purpose or value proposition to its visitors and motivate them to take a certain action—be it make a purchase, subscribe to a newsletter, etc. It's a critical component in search engine optimization (SEO) as search engines rank websites based on the quality and relevance of the website's copy to user searches. Markdown, a lightweight markup language, can be used to write web copy; it allows writers to format text (like headers, lists, and links) in plain text which will then be converted into HTML for web display.",
+    "links": []
+  },
+  "XyFEYDJvJpGZ7qSdoSZeI": {
+    "title": "Content Optimization",
+    "description": "\"Content Optimization\" is a vital technique in digital writing, focusing on making your content more appealing and useful to your target audience. It involves several strategies such as keyword usage, meta-tag optimization, using relevant links and references, maintaining proper content length, utilizing images and infographics effectively, and ensuring a mobile-friendly layout. Also, optimization of your content for search engines (SEO) is vital, enabling your content to rank higher in search rankings. However, it's not just about SEO; attention must be given to the readability, clarity, and overall user experience. The aim is to both engage human readership and satisfy search engine algorithms. Remember, content optimization isn't a one-time process but requires regular updates and review for achieving consistent advantages.",
+    "links": []
+  },
+  "TbSBCITdLswhVB82fErTP": {
+    "title": "Content Analysis",
+    "description": "Content Analysis is a research methodology used by technical writers to interpret and quantify textual data. It involves a systematic process of coding and identifying themes or patterns within a body of text from different sources such as books, blogs, articles, or other document types. The primary goal is to provide a subjectively interpreted, yet valid and replicatable, inference from the data. This technique helps decipher whether the content in question conveys the desired communication effectively or if there are areas that require improvement. For example, you may conduct a content analysis to measure the user-friendliness of a software manual or the clarity and comprehensibility of an instructional guide.",
+    "links": []
+  },
+  "qpOfqbgLy5TzlNQEyt6DG": {
+    "title": "Link Shorteners / Tracking",
+    "description": "URL shorteners, as the name suggests, are tools that allow you to shorten the length of any given URL. These can be extremely handy, especially in situations where you're dealing with very long and complex URLs with several parameters. A few examples of these tools include [Bit.ly](http://Bit.ly), TinyURL, and Google URL Shortener (now defunct, replaced by Firebase Dynamic Links). They work by creating a unique short link for your long URL, and then redirecting anyone who clicks on it to the original link. This simplifies the URL and makes it easier to share with others, either verbally or digitally. While these tools are straightforward to use, it's always a good idea to familiarize yourself with how they work and any associated privacy or security implications. Markdown is not particularly required for URL shorteners as they take any kind of link, regardless of the content.",
+    "links": []
+  },
+  "hlhBgI3SvU3tMtNaHtu8k": {
+    "title": "Platform Tracking and Metrics",
+    "description": "`Platform tracking` in the context of technical writing refers to the process of monitoring and analyzing how users interact with a particular content on different platforms. It involves tracking user behavior, content read, the devices used, operating systems, geographical location, time spent, and more. This data helps understand how effectively the content serves its purpose across various platforms. It's important to note that platform tracking should always respect user privacy and data protection regulations.",
+    "links": []
+  },
+  "UiXn-CnPcLWAflKJzaJ2a": {
+    "title": "Conversion Tracking",
+    "description": "`Conversion Tracking` is a powerful tool in online marketing and business analytics. It allows you to identify how well your campaign, ads, prompts, or any other initiative is working by tracking how users interact and convert on your site or app. `Conversion` can be actions such as signing up for a newsletter, downloading a file, making a purchase, or any other key performance indicator (KPI) for your project. Essentially, `Conversion Tracking` involves placing a piece of code, often known as a pixel, on your website or app. Once a user performs an action that you've defined as a 'conversion', this pixel is triggered and records the action. By implementing conversion tracking across different digital platforms, you can effectively decode user behavior, and use these insights to optimize your ongoing and future campaigns for better performance.",
+    "links": []
+  },
+  "JgdrXG7MX1gGuNG9uyubA": {
+    "title": "Content Aging & Timelines",
+    "description": "`Content Aging` refers to the natural process where the information or data presented becomes outdated or irrelevant over time. This typically happens in rapidly evolving industries or topics, where new developments or advancements regularly occur. As a technical writer, it's crucial to regularly review and update your content to ensure its accuracy and relevance. Ignored, aged content can lead to misinformation, confusion, and loss of trust among your readers. Therefore, a systematic approach to manage content aging, like implementing a review cycle or updating schedule, is an integral part of content management strategy.",
+    "links": []
+  },
+  "mrqBxsNRl1CQEKtuYSy9F": {
+    "title": "Content Distribution",
+    "description": "Content distribution refers to the process of sharing, publishing, or disseminating content to your audience through various mediums. These mediums can include different channels like social media platforms (Facebook, Twitter, LinkedIn, etc.), email newsletters, blogs, podcasts, websites, or even offline venues like magazines and newspapers. The nature of content being distributed can range from blog posts, articles, videos, infographics, to podcasts. The aim of content distribution is to make your content accessible to as many relevant audiences as possible, increasing reach, visibility, and engagement. The strategy may involve both organic and paid means of distribution, and typically pursues a multichannel approach to maximize reach.",
+    "links": []
+  },
+  "NIxIhMEOxrUR8nbjbF_Fp": {
+    "title": "Canonical Link",
+    "description": "A `canonical link` is an HTML element that helps prevent duplicate content in search engine optimization by specifying the \"preferred\" version of a page. The canonical tag is added to the HTML head of a page and has a link leading to the version of the web page that is the most complete or authoritative. Irrespective of the number of URLs pointing to similar content, the canonical link denotes which is the key version. This is crucial in guiding search engine bots to index and rank the right pages.",
+    "links": []
+  },
+  "AarJ887P-SFRnKaOOv9yw": {
+    "title": "OpenGraph Data",
+    "description": "OpenGraph is a technology first introduced by Facebook in 2010 that allows integration between the social media platform, user's website, and their shared content. It works by allowing any web page to become a rich object in a social network by adding basic metadata to the page. With the help of OpenGraph protocol, we can use a web page as a part of a social graph. It is used to control how URLs are presented when they are shared on social media. The data includes details like the title of the content, description, URL, and an associated image.\\`\\`\\`markdown\n\nOpenGraph Data\n--------------\n\nOpenGraph data is a protocol that enables any web page to become a rich object in a social graph. It was introduced by Facebook to allow for an integration between the user's website, Facebook, and any shared content. OpenGraph involves adding basic metadata to a page, enabling it to be used as part of a social graph. This metadata can control how URLs are presented when shared on social media, encompassing details such as the title, description, URL, and corresponding image of the content.",
+    "links": []
+  },
+  "m9-DqsQfeukmhjhIfCph-": {
+    "title": "Content Distribution Channels",
+    "description": "Content distribution channels refer to the mediums through which content creators disseminate their work to reach their chosen audience. Broadly, these channels can be divided into three categories: owned, earned, and paid. Owned channels are those controlled by the content creators themselves, such as their websites, blogs or email newsletters. Earned channels are ones where others distribute the content on the creator's behalf out of their own desire, such as shares on social media or word-of-mouth recommendations. Paid channels, as the name implies, are those where content creators pay to have their work distributed, such as through sponsored posts or advertisements on social media, promotional emails, or paid search results in search engines.",
+    "links": []
+  },
+  "_cAGbAswDhOqpoiiikPbD": {
+    "title": "Content Distribution Amplification Strategies",
+    "description": "In technical writing, **amplification strategies** are tactics utilized to increase the reach and impact of the content produced. This often involves promoting and sharing the content through various mediums to ensure it gets in front of the largest and most relevant audience. These strategies can include everything from social media promotion and email marketing campaigns to leveraging influencers and using SEO (Search Engine Optimization) strategies. Additionally, they can also involve repurposing content into different formats (like infographics or videos) to engage wider demographics. These amplification techniques help to maximize the reach and effectiveness of the technical content produced.",
+    "links": []
+  }
+}

public/roadmap-content/ux-design.json

@@ -0,0 +1,512 @@
+{
+  "liUKYf7UghuPk25xMPPYj": {
+    "title": "Human Decision Making",
+    "description": "Human decision making is the cognitive process through which individuals analyze information, evaluate alternatives, and select a course of action based on their preferences, goals, and desires. It plays a vital role in the field of UX design, as designers must understand how users make decisions in order to create intuitive and efficient interfaces.\n\nFactors Influencing Decision Making\n-----------------------------------\n\n*   **Cognitive biases**: These are mental shortcuts or patterns of thinking that can influence decision making. Examples include anchoring bias (relying too heavily on initial information) and confirmation bias (seeking information that confirms beliefs).\n*   **Emotions**: Emotions can significantly sway decisions, even when people believe they are making rational choices. UX designers should consider how design elements can elicit positive emotions and minimize negative ones.\n*   **Information overload**: Too much information can lead to cognitive overload and negatively impact decision making. UX designers need to organize and present information in a digestible and accessible way.\n\nDecision Making Models\n----------------------\n\nUnderstanding different decision-making models helps UX designers create interfaces that cater to various user needs and preferences. Some common models include:\n\n*   **Compensatory model**: In this model, individuals consider all available options, weighing their pros and cons in a systematic manner. UX design implications include providing detailed information, filters, and comparisons to help users make informed decisions.\n*   **Non-compensatory model**: Here, users employ a variety of heuristics or shortcuts to make decisions quickly. This may involve relying on a single attribute or establishing a threshold for certain criteria. In these cases, UX design should focus on highlighting key features and simplifying the decision-making process.\n*   **Satisficing model**: In this approach, users make decisions by selecting the first available option that meets their minimum criteria. UX designers should consider implementing features like 'top choices' and recommendations to support this decision-making style.\n\nDesign Principles for Supporting Decision Making\n------------------------------------------------\n\nTo enhance user decision-making experience, consider the following principles:\n\n*   **Progressive disclosure**: Present information gradually to avoid overwhelming users. This technique can include using tooltips, labels and expanding sections.\n*   **Cognitive aids**: Help users remember important information or tasks by providing timely reminders, notifications, and visual cues.\n*   **Feedback**: Instant feedback can help users understand the results of their decisions and guide them towards desired outcomes. This can be achieved through visual cues, messages, and animations.\n*   **Defaults**: Use smart defaults to help users make decisions in a context-appropriate manner, which could range from pre-filled forms to suggested options.\n\nUnderstanding human decision making and incorporating these principles into UX design will enable designers to create more intuitive, enjoyable, and efficient user experiences.",
+    "links": [
+      {
+        "title": "List of Cognitive Biases",
+        "url": "https://thedecisionlab.com/biases",
+        "type": "article"
+      },
+      {
+        "title": "Types of Cognitive Bias",
+        "url": "https://www.youtube.com/watch?v=wEwGBIr_RIw",
+        "type": "video"
+      }
+    ]
+  },
+  "6ffY5wO-XhkiDJJ5YcI0x": {
+    "title": "Nudge Theory",
+    "description": "**Nudge Theory** is a behavioral science concept that focuses on understanding how humans make choices and how small, subtle changes in our environment can have a significant impact on our decision-making process. Developed by Richard Thaler and Cass Sunstein, the central idea is that by \"nudging\" people's behavior in a specific direction, we can encourage them to make better, more informed decisions without the need for heavy-handed rules or regulations.\n\nIn the context of UX design, nudge theory can be applied in various ways to influence user behavior and drive desired outcomes. This might include:\n\n*   **Choice Architecture**: Designing the layout and ordering of choices in a way that influences user decisions. For example, placing more desirable options at the top of a list or making them more visually prominent.\n*   **Defaults**: Setting default options that encourage users to make better decisions. For example, pre-selecting a more environmentally-friendly shipping option or having a privacy setting enabled by default.\n*   **Social proof**: Showing how others have made similar choices or have had positive experiences. For example, presenting product ratings and reviews, or indicating that a large number of users have taken a particular action such as signing up for a newsletter.\n*   **Timely interventions**: Providing guidance or prompts at the right moment in the user's journey. For example, offering help when a user encounters a complex task or reminding them of the benefits of completing a process when their motivation may be wavering.\n\nWhen applying nudge theory in UX design, it's crucial to maintain a balance between encouraging positive behaviors and respecting user autonomy. Designers should aim to empower users with meaningful choices and useful information, rather than manipulating or deceiving them.",
+    "links": [
+      {
+        "title": "Nudge Theory overview with examples",
+        "url": "https://www.businessballs.com/improving-workplace-performance/nudge-theory/",
+        "type": "article"
+      },
+      {
+        "title": "Nudge Theory Explained in less than 10 minutes",
+        "url": "https://youtu.be/fA5eGIMZTRQ",
+        "type": "video"
+      }
+    ]
+  },
+  "K22gvF9DLt0Ikc80yZLCb": {
+    "title": "Persuasive Technology",
+    "description": "Persuasive technology is an area of UX design that focuses on using technology to influence human behavior and encourage users to take specific actions. It combines the principles of psychology and design to create experiences that impact user behavior in a desired way. The goal of persuasive technology is to subtly persuade or encourage users to adopt specific habits or behaviors, often with the intent of improving their overall experience or achieving a particular outcome.\n\nSome common examples of persuasive technology include:\n\n*   **Reinforcement**: Providing users with positive feedback or rewards for completing specific actions (e.g., badges or points in a gamified interface).\n    \n*   **Social influence**: Leveraging social connections and norms to encourage actions or decisions, such as displaying the number of friends who have also enjoyed a product on a shopping site.\n    \n*   **Scarcity**: Using the concept of scarcity (limited availability, time-limited offers) to instill a sense of urgency in users and encourage them to take action before they miss out.\n    \n*   **Personalization**: Tailoring content or experiences to the individual user based on their preferences, behaviors, or demographic information, which makes the experience more relevant and engaging.\n    \n*   **Commitment and consistency**: Encouraging users to make small commitments with the intent to build towards larger commitments over time, often through a progression of small tasks or milestones.\n    \n\nIncorporating persuasive technology into UX design can lead to more engaging and effective user experiences. However, it's crucial to use these techniques responsibly and ethically, ensuring that the end goal aligns with the best interests of users and does not exploit or manipulate them in any negative way.",
+    "links": []
+  },
+  "zYCBEUqZVlvjlAKnh5cPQ": {
+    "title": "Behavior Design",
+    "description": "Behavior Design is an approach that combines elements of psychology, neuroscience, and design principles to understand and influence human behaviors. The goal behind behavior design is to make it easier for users to accomplish their goals or desired actions within a product, service, or system.\n\nIn the context of UX Design, behavior design focuses on:\n\n*   **Motivation**: Understanding what motivates users to take action, such as personal interests, external rewards, or social influence.\n    \n*   **Ability**: Ensuring that users have the necessary skills, time, and resources to complete a desired action.\n    \n*   **Triggers**: Implementing well-timed prompts that encourage users to take a specific action within the interface.\n    \n\nTo create effective behavior designs, UX designers should:\n\n*   Identify user goals and desired outcomes.\n*   Analyze the user's environment and potential barriers that may affect their ability to complete the desired action.\n*   Design solutions that address both the motivation and ability aspects of behavior change, as well as the appropriate triggers to prompt action.\n*   Continuously test and iterate on the design to better understand user behavior and optimize engagement.\n\nBy focusing on behavior design, UX designers can create more engaging and user-friendly experiences that ultimately drive user satisfaction and increase the chances of achieving their desired goals.",
+    "links": []
+  },
+  "D553-nVELaB5gdxtoKSVc": {
+    "title": "Behavioral Science",
+    "description": "Behavioral science is the interdisciplinary study of human behavior, which encompasses disciplines like psychology, sociology, and anthropology. This field- primarily focuses on understanding what impacts our decisions, actions, and emotions. In the context of UX design, applying behavioral science concepts and principles can enhance user experience by improving user engagement, usability, and overall satisfaction.\n\nSome key principles of behavioral science that UX designers should consider include:\n\n*   **Cognitive biases:** These are mental shortcuts our brains take when processing information which can lead to irrational decisions or judgments. Designers can use these biases to guide user behavior, as seen in the 'anchoring effect,' where users rely on the first piece of information provided on a page.\n    \n*   **Loss aversion:** People tend to prioritize avoiding losses over acquiring gains. Designers can use this to their advantage by highlighting potential losses that could occur without using a specific feature or product, increasing user motivation.\n    \n*   **Social proof:** People look to others for cues about how to behave in uncertain situations. To leverage this effect, designers can include testimonials, ratings, and user-generated content to demonstrate that others have found value in their product or service.\n    \n*   **Incentivization:** Users may be more likely to engage with a product if there are rewards or incentives for completing certain tasks. Gamifying an experience or offering exclusive benefits can encourage users to engage more deeply with the product.\n    \n*   **Choice architecture:** The way choices are presented influences users' decisions. Designers can use this to guide users to desired outcomes or simplify decision-making by reducing the number of options presented.\n    \n*   **Habit formation:** Creating a habit-forming experience can lead to increased user retention and engagement. Designers should consider features and elements that reinforce routine usage or solve recurring pain-points.\n    \n\nBy integrating behavioral science principles into their design process, UX designers can better understand and anticipate users' needs, ultimately creating more enjoyable, effective, and engaging experiences.",
+    "links": []
+  },
+  "_lv6GJ0wlMfhJ7PHRGQ_V": {
+    "title": "Behavioral Economics",
+    "description": "Behavioral Economics is a subfield of economics that studies the psychological, social, and emotional factors that influence decision-making and economic behavior. It seeks to understand why people make choices that deviate from the traditional economic model, which assumes that individuals behave rationally and seek to maximize their utility.\n\nThe key concepts of Behavioral Economics include:\n\n*   Bounded Rationality: People make decisions based on limited information, cognitive constraints, and personal biases.\n    \n*   Prospect Theory: Individuals perceive losses and gains asymmetrically, feeling greater pain from a loss than satisfaction from an equivalent gain.\n    \n*   Anchoring: People tend to rely on a reference point (the anchor) when assessing the value of an unknown option, which can lead to arbitrary or irrational decisions.\n    \n*   Mental Accounting: Individuals mentally categorize and allocate expenses differently, which can lead to biases like the sunk cost fallacy or the endowment effect.\n    \n*   Nudging: Subtle changes to choice architecture can influence people's decisions without restricting their freedom of choice, through methods like default options, framing, or social proof.\n    \n\nUnderstanding and applying behavioral economic principles can help UX designers create interfaces and experiences that account for these biases and help users make better choices. By designing to minimize cognitive load, supporting decision-making, and presenting options effectively, UX designers can enhance user satisfaction and encourage desired actions.",
+    "links": []
+  },
+  "2NlgbLeLBYwZX2u2rKkIO": {
+    "title": "BJ Fogg's Behavior Model",
+    "description": "B.J. Fogg, a renowned psychologist, and researcher at Stanford University, proposed the [Fogg Behavior Model (FBM)](https://www.behaviormodel.org/). This insightful model helps UX designers understand and influence user behavior by focusing on three core elements. These key factors are motivation, ability, and prompts.\n\n*   **Motivation**: This element emphasizes the user's desire to perform a certain action or attain specific outcomes. Motivation can be linked to three core elements specified as sensation (pleasure/pain), anticipation (hope/fear), and social cohesion (belonging/rejection).\n    \n*   **Ability**: Ability refers to the user's capacity, both physical and mental, to perform desired actions. To enhance the ability of users, UX designers should follow the principle of simplicity. The easier it is to perform an action, the more likely users will engage with the product. Some factors to consider are time, financial resources, physical efforts, and cognitive load.\n    \n*   **Prompts**: Prompts are the cues, notifications, or triggers that signal users to take an action. For an action to occur, prompts should be presented at the right time when the user has adequate motivation and ability.\n    \n\nUX designers should strive to find the balance between these three factors to facilitate the desired user behavior. By understanding your audience and their needs, implementing clear and concise prompts, and minimizing the effort required for action, the FBM can be an effective tool for designing user-centered products.",
+    "links": [
+      {
+        "title": "meaning of BJ fogg's behavior model",
+        "url": "https://behaviormodel.org/",
+        "type": "article"
+      }
+    ]
+  },
+  "kcG4IpneJzA6di0uqTiwb": {
+    "title": "CREATE Action Funnel",
+    "description": "Stephen Wendel's CREATE Action Funnel is a behavioral design framework aimed at helping individuals or organizations encourage specific behaviors in others, especially in the context of product design. It breaks down the process of motivating action into six key stages. Each stage helps identify where users might drop off or face barriers, allowing designers or strategists to address these pain points effectively. These stages are:\n\n*   **CUE:** The user must notice a cue or prompt that tells them to act. This could be a notification, a visual element, or any kind of reminder.\n    \n*   **REACTION:** The user must react positively to the cue. This stage involves emotional and cognitive processing, where the individual decides if the action is relevant or attractive.\n    \n*   **EVALUATION:** The user evaluates whether the action is worth their time, energy, or resources. They assess the benefits versus the effort required.\n    \n*   **ABILITY:** The user must feel capable of taking the action. This involves ensuring that the action is easy enough to do and aligns with their skills and resources.\n    \n*   **TIMING:** The action needs to happen at the right time. Users need to have the opportunity and be in the right context to act.\n    \n*   **EXECUTION:** Finally, the action must be carried out successfully. This is the stage where the behavior is completed.\n    \n\nThe CREATE Action Funnel is helpful for product designers, marketers, or behavior change professionals, as it provides a structured way to understand user actions and design interventions to improve completion rates. It identifies and solves the gaps that occur between intention and action.",
+    "links": [
+      {
+        "title": "Behavioral Science Crash Course: Steve Wendel's CREATE Action Funnel",
+        "url": "https://www.prodify.group/blog/behavioral-science-crash-course-steve-wendels-create-action-funnel",
+        "type": "article"
+      }
+    ]
+  },
+  "0Df110GZcDw5wbAe1eKoA": {
+    "title": "Spectrum of Thinking Interventions",
+    "description": "The _Spectrum of Thinking Interventions_ provides a structure for understanding the different types of decision-making processes by illustrating how our minds would respond in a _default, lowest energy way_, if we didn't consciously do something different. This spectrum ranges from situations requiring minimal thought to those demanding intensive thinking, and includes the mechanisms (\"interventions\") that our minds will likely use.\n\n*   **Habits:** Triggering a learned routine based on familiar cues\n*   **Other intuitive responses:** Used in familiar or semi-familiar situations, with responses based on past experiences\n*   **Active mindset or self-concept:** Used in ambiguous scenarios with multiple possible interpretations\n*   **Heuristics:** Used in situations requiring conscious attention, but where decisions can be made more easily\n*   **Focused, conscious calculation:** Used in unfamiliar scenarios or crucial decisions where deliberate focus is needed\n\nWith this spectrum in mind, it is essential as a UX designer to leverage on the mind's decision-making process, analyze which mechanisms are most applicable to your target users and design the most accessible and effective solutions.",
+    "links": []
+  },
+  "kWA8CvocP1pkom2N7O4gb": {
+    "title": "Dual Process Theory",
+    "description": "The Dual Process Theory is a psychological concept that suggests that human thinking operates on two different levels – an intuitive, fast, and automatic level (known as System 1), as well as a more deliberate, slow, and logical level (System 2). In the context of UX design, understanding these two systems can help designers create user interfaces and experiences that cater to both types of thinking.\n\n**System 1: Intuitive and Fast**\n\n*   Relies on intuition, heuristics, and mental shortcuts\n*   Makes quick judgments based on emotions and past experiences\n*   Prone to errors and biases, but highly efficient for everyday tasks\n\n**System 2: Deliberate and Slow**\n\n*   Involves conscious, controlled thinking and decision making\n*   Requires more mental effort and can handle complex problems\n*   Less prone to errors, but slower and more resource-intensive\n\nIn order to create user experiences that cater to both System 1 and System 2 thinking, UX designers should:\n\n*   **Make tasks simple and intuitive**: Reduce cognitive load by simplifying tasks, using familiar patterns, and providing clear instructions.\n*   **Provide visual cues**: Use visual cues such as icons, colors, and typography to guide users through tasks, while promoting clarity and efficiency.\n*   **Minimize errors**: Design systems that help prevent errors by using constraints, providing feedback, and allowing users to undo their actions.\n*   **Accommodate different thinking styles**: Recognize that different users may approach tasks using different cognitive styles, and design experiences that cater to a range of preferences.\n*   **Test and iterate**: Continuously test your designs with real users, and iterate based on their feedback to ensure that your designs are catering to both System 1 and System 2 thinking.\n\nBy understanding the Dual Process Theory and designing for both types of cognitive processing, UX designers can create user experiences that are both delightful and efficient, ultimately leading to higher user satisfaction and engagement.",
+    "links": []
+  },
+  "lRBC8VYJPsR65LHDuuIsL": {
+    "title": "BJ Fogg's Behavior Grid",
+    "description": "The BJ Fogg Behavior Grid is a framework that helps UX designers, product managers, and marketers understand and identify different types of behavior change. Created by Stanford University professor B.J. Fogg, the grid consists of 15 behavior types based on the combination of three dimensions: Duration, Frequency, and Intensity.\n\nDuration\n--------\n\n*   **One-time behaviors**: These are behaviors that happen only once (e.g., signing up for an account).\n*   **Short-term behaviors**: Behaviors that take place for a limited period of time (e.g., using a trial version of a product).\n*   **Long-term behaviors**: Behaviors that are ongoing or happen repeatedly over a considerable time (e.g., continued use of a product).\n\nFrequency\n---------\n\n*   **Single-instance behaviors**: Behaviors that occur only one time per occasion (e.g., entering a password once to log in)\n*   **Infrequent behaviors**: Behaviors that do not happen regularly or happen sporadically (e.g., posting on social media once a week)\n*   **Frequent behaviors**: Behaviors that happen on a consistent and regular basis (e.g., checking email multiple times a day)\n\nIntensity\n---------\n\n*   **Low-stakes behaviors**: Behaviors that have little impact or are considered less important (e.g., choosing a profile picture)\n*   **Medium-stakes behaviors**: Behaviors that have moderate importance or impact (e.g., deciding how much personal information to share)\n*   **High-stakes behaviors**: Behaviors that have significant impact on the user's experience or perception of the product (e.g., making a purchase or canceling a subscription)\n\nUsing this grid, designers can classify user behaviors into different types and tailor their UX design strategies to target the specific behavior they want to encourage, change, or eliminate. Additionally, the Behavior Grid can be used to analyze and understand user motivations, triggers, and barriers, enabling designers to create more effective behavior change interventions.",
+    "links": []
+  },
+  "PLLTcrHkhd1KYaMSRKALp": {
+    "title": "Nir Eyal's Hook Model",
+    "description": "The Hook Model is a concept developed by Nir Eyal, a writer and entrepreneur. It is a framework designed to help create habit-forming products and services by engaging users on a deeper level. Eyal's model is based on four key components, which are meant to encourage user interactions and repeat usage, ultimately leading to user addiction. These components are:\n\n*   **Trigger:** Triggers are cues that prompt users to take action, either through external stimuli or internal motivations. External triggers can be notifications, advertisements, or even recommendations from friends, while internal triggers stem from users' thoughts or emotions, such as boredom or a need for social connection.\n    \n*   **Action:** The action is the simple task the user performs in response to the trigger. The action will depend on the context and product, but generally, it should be easy to do and have a clear connection to the trigger. An example might be swiping left or right on a dating app after receiving a notification.\n    \n*   **Variable Reward:** Rewarding users for taking action is an essential part of the Hook Model. Variable rewards refer to the idea that users receive varying levels of gratification for their actions - this unpredictability keeps them engaged and curious. Social media platforms are excellent examples, as users receive likes, comments, or retweets randomly, prompting them to keep interacting to trigger more rewards.\n    \n*   **Investment:** This component focuses on users investing time or effort into the product, which increases the likelihood of future engagement. An investment might include creating a profile, adding friends, or curating content. Users often feel a sense of ownership after investing in a product, making them more likely to return and continue using it.\n    \n\nBy incorporating these components into your UX design, you can create experiences that encourage users to develop habits and become more attached to your product. Keep in mind, however, that \"addiction\" is not the primary goal - rather, it's about promoting genuine value and enhancing users' lives in a positive manner.",
+    "links": []
+  },
+  "X1AroUI8Fge_lRpKab4A9": {
+    "title": "Cue Routine Reward Model",
+    "description": "The Cue-Routine-Reward Model, also known as the Habit Loop, is a neurological framework that describes how habits are formed and maintained in our brains. By understanding this model, UX designers can create more engaging and addictive user experiences, encouraging users to come back to the product repeatedly. The model consists of three key components:\n\n*   **Cue**: A stimulus, or trigger, that prompts your brain to start a habit. This can be anything from a notification on your phone to a daily routine or a specific location.\n\n    Example: Receiving an email notification (Cue) prompts you to check your inbox.\n    \n\n*   **Routine**: The actual habit or default action you take in response to the cue. This is typically an automated behavior that occurs without much conscious thought.\n\n    Example: After receiving the email notification (Cue), you open your email app and read the message (Routine).\n    \n\n*   **Reward**: The satisfaction or positive reinforcement your brain gets from completing the routine. This release of dopamine in the brain helps to strengthen and reinforce the habit over time.\n\n    Example: Reading the email (Routine) gives you a sense of accomplishment or connection with the sender, resulting in a positive emotion (Reward).\n    \n\nTo apply the Cue-Routine-Reward model in UX design:\n\n*   Identify potential **cues** that can act as triggers for users to engage with your product. This can include push notifications, visual prompts, or personalized messages.\n    \n*   Design seamless **routines** that are intuitive, user-friendly, and make it easy for users to complete tasks within the product. This can involve anything from clear calls-to-action, minimalist design, or familiar design patterns.\n    \n*   Ensure a meaningful **reward** is provided to users so they feel a sense of accomplishment or receive some form of positive feedback. This can include personalized content, social validation, or progress tracking.\n    \n\nBy incorporating the Cue-Routine-Reward model into your UX design, you can tap into users' natural habit-forming tendencies and ultimately create more addictive, engaging experiences.",
+    "links": []
+  },
+  "PTZROvpPtEvu06szwmt4K": {
+    "title": "Support Conscious Action",
+    "description": "The process of changing user behavior involves understanding the factors that influence the way people interact with your product, and applying strategies to help users adopt new, desirable behaviors. The goal is to make users feel comfortable and confident while using your product, ultimately creating a more enjoyable and effective user experience.\n\nThere are several key principles and strategies for changing user behavior in UX design:\n\n*   **Understand the user's current behavior**: To effectively change user behavior, you first need to understand their current habits and patterns. Conduct user research through interviews, surveys, and observation to identify their pain points and motivations.\n    \n*   **Set clear goals**: Define specific, measurable, attainable, and relevant goals for the behavior change you want to achieve. This might include increasing the number of completed tasks or reducing the time taken to complete tasks.\n    \n*   **Leverage behavioral psychology**: Utilize theories and models from behavioral psychology, such as the Fogg Behavior Model or the Theory of Planned Behavior, to design interventions that target key aspects of user behavior. These models can help explain the relationship between different factors that influence behavior, such as motivation, ability, and triggers.\n    \n*   **Design for simplicity**: Make it as easy as possible for users to adopt the desired behavior. Reduce barriers, streamline processes, and minimize the cognitive load required to perform tasks.\n    \n*   **Provide feedback and reinforcement**: Help users understand the impact of their actions by providing immediate, clear, and specific feedback. Positive reinforcement, such as rewards or praise, can also encourage users to continue engaging in the desired behavior.\n    \n*   **Leverage social influence**: People are often influenced by the behaviors of others, so consider incorporating elements of social proof, competition, or collaboration into your UX design.\n    \n*   **Personalize the experience**: Tailor your onboarding process, messaging, and content to the individual preferences and learning styles of your users. This can improve engagement and increase the likelihood of behavior change.\n    \n*   **Iterate and evaluate**: Continuously test and refine your design to improve the effectiveness of your behavior change strategies. Evaluate the success of your interventions by measuring changes in user behavior and adjusting your approach accordingly.\n    \n\nBy applying these strategies in your UX design, you can change user behavior and drive positive outcomes for your users and your product.",
+    "links": []
+  },
+  "SLXjoYL-lhPef8s9V3jpf": {
+    "title": "Educate & Encourage User",
+    "description": "One of the primary goals of UX design is to guide users through the intended flow of an application or website, and that often involves encouraging them to change their behavior or habits. Educating and encouraging users can be achieved through various methods such as guidance, feedback, and positive reinforcement.\n\n*   **Guidance:** Provide clear and concise instructions, explanations, and help text to ensure users understand how to use your application. Using onboarding tutorials, tooltips, and contextual help can greatly improve the user experience and aid in changing their behavior if required.\n    \n    *   Example: Show a brief tutorial during a user's first interaction with your app, highlighting key features they may not be aware of.\n*   **Feedback:** Give users real-time feedback as they interact with your application. This can range from basic notifications to more detailed information tailored to their specific behaviors.\n    \n    *   Example: When a user creates a password, show an interactive strength meter indicating whether their chosen password is strong or weak. This may encourage the user to choose a stronger and more secure password.\n*   **Positive reinforcement:** Encourage users to continue using your application by rewarding them for achieving milestones or completing tasks. This can be achieved through gamification elements like badges, points, and progress indicators.\n    \n    *   Example: Award a badge to users who complete their profile or connect their social media accounts. This can encourage users to fully engage with your application and form a habit of using it regularly.\n*   **Social influence:** Utilize social proof to promote a change in user behavior. Showcasing the actions or opinions of other users can create a sense of community and drive users to follow suit.\n    \n    *   Example: Display the number of users who have completed a task or upvoted a piece of content, which may motivate other users to follow the apparent trend.\n*   **Personalization:** Cater to users by presenting them with tailored content based on their preferences, usage patterns, and prior interactions. Personalization can make users feel more invested in the application, which may encourage them to consistently use and engage with it.\n    \n    *   Example: Offer users personalized recommendations for articles or products based on their browsing history, which can enhance their experience and increase the likelihood of repeat visits.\n\nBy effectively educating and encouraging your users, you can create a user experience that promotes desired behaviors, fosters positive habits, and ultimately leads to a more successful and impactful application. Remember to always put your user at the center of your design process to ensure you're addressing their needs and desires in the most effective way possible.",
+    "links": []
+  },
+  "e9n9an1PGxDPGkLCOHIwz": {
+    "title": "Help User think about their Action",
+    "description": "To successfully change user behavior, it's crucial to encourage users to think about their actions consciously. This can be achieved by employing various strategies in your UX design. Following are some effective methods to help users think about their actions:\n\n*   **Incentives**: Offer rewards or incentives to the users for completing specific actions, which will make them more likely to think about their actions and participate actively in the process.\n    \n*   **Progress indicators**: Display clear progress indicators to show the user where they are in the process and how far they've come. This will help the user evaluate the outcomes of their actions and motivate them to complete the process.\n    \n*   **Feedback**: Providing users with real-time feedback on their actions is a great way to make them more conscious of their actions. You can use notifications, messages, or visual cues to inform users about the positive or negative results of their actions.\n    \n*   **Guidance**: Offer guidance and support to users as they engage with your interface. Through onboarding tutorials, tooltips, or context-based instructions, help users understand the effects of their actions, why they are relevant, and how to use them efficiently.\n    \n*   **Confirmation**: Ask users for confirmation before they proceed with a critical action that may have significant consequences. This pause will compel them to think about their choice and assess the potential impact of their action.\n    \n*   **Make it personal**: Connect the outcomes of the user's actions to their personal goals or aspirations. Users are more likely to think about their actions if they perceive the effects in the context of their own life.\n    \n\nBy incorporating these techniques within your UX design, you will encourage users to actively think about their actions, leading to more mindful engagement with your product, informed decision-making, and improved user satisfaction.",
+    "links": []
+  },
+  "zVXJPpqZvUFIxTGVrr0rN": {
+    "title": "Cheating",
+    "description": "Cheating, in the context of behavior change strategies, refers to creating shortcuts and loopholes within a designed system, in order to overcome any obstacles users may face while achieving their goals. As a UX designer, you need to understand that users often look for the easiest path to reach their objectives, even if it means bending or breaking the established rules.\n\nWhen to use Cheating:\n---------------------\n\n*   **Overcoming limitations**: Allow users to overcome constraints imposed by the system or environment when these limitations prevent them from moving forward in a meaningful way.\n*   **Increasing motivation**: When users feel stuck or overwhelmed, cheating mechanisms can help them feel a sense of progress or achievement, thus motivating them to keep going.\n*   **Enhancing user experience**: Sometimes, cheating can create fun and engaging experiences, turning ordinary tasks into enjoyable challenges that users might enjoy exploring and exploiting.\n\nDesigning for Cheating:\n-----------------------\n\nWhen designing cheat mechanisms in your UX, consider the following best practices:\n\n*   **Balance**: Cheating should provide an alternative solution without compromising the overall challenge or value offered by the system. Strive for a balance between making tasks easier and avoiding excessive exploitation that could lead to unearned rewards or trivializing the user's experience.\n*   **Limited Access**: Cheating should not become the default behavior or the most commonly used strategy in your design. Limit access or opportunities to cheat to avoid undermining the user's sense of accomplishment or alienating non-cheating users.\n*   **Documentation and communication**: If permitting cheating is an intentional design choice, communicate this to your users explicitly, so they don't feel guilty about exploiting loopholes. Making users aware of cheat options can help you foster an environment where users knowingly bend the rules, thus adding an interesting dynamic to the overall user experience.\n*   **Monitoring**: Constantly monitor how users are interacting with your design and how prevalent cheating behavior is. If cheating becomes too widespread or harmful, consider tweaking the system and addressing any unintended consequences.\n\nBy carefully designing and implementing cheating strategies, you can effectively enhance the user experience, while still maintaining the integrity of your system and the motivation of your users. Remember, the goal is to make the experience enjoyable and rewarding, not to provide users with a way to cheat their way to success.",
+    "links": []
+  },
+  "IpKCXqf_PkxIllwmiIZsq": {
+    "title": "Defaulting",
+    "description": "Defaulting in UX design refers to the practice of pre-selecting options or settings for users based on what is likely to be the most common or preferred choice. The goal is to simplify the decision-making process and minimize the effort required for users to complete a task or interact with an interface.\n\nBenefits of defaulting include:\n\n*   **User convenience**: By pre-selecting options for users, you save them time and effort in making choices. This leads to a smoother user experience, especially for users who may not have a strong preference or in-depth knowledge about the task at hand.\n    \n*   **Reduced errors and confusion**: Default options can help users avoid making errors, like selecting an incompatible format or an incorrect setting. By choosing sensible defaults, you can guide users towards appropriate choices which can minimize confusion and potential problems later on.\n    \n*   **Promote desired behavior**: If you want to encourage users to adopt a specific action or setting, making it the default choice can increase its adoption rate. For example, setting the default privacy settings to 'high' can promote better security practices among users.\n    \n\nWhen implementing defaulting, keep the following guidelines in mind:\n\n*   **Consider user needs and preferences**: Defaults should align with the most common or preferred user actions, based on user research and understanding of your audience.\n    \n*   **Be transparent**: Make it clear to users that you have pre-selected some choices on their behalf, and offer ways to change these selections if needed.\n    \n*   **Regularly review and adjust**: As your user base or product evolves, it's essential to review and adjust your default settings to ensure they remain relevant and helpful to users.\n    \n\nIn summary, defaulting is a powerful UX design technique that, when used thoughtfully, can streamline user interactions and lead to better usability and user satisfaction.",
+    "links": [
+      {
+        "title": "The Power of Defaults",
+        "url": "https://www.nngroup.com/articles/the-power-of-defaults/",
+        "type": "article"
+      }
+    ]
+  },
+  "Ix5Fll_dAINWLxVF2DXFI": {
+    "title": "Making it Incidental",
+    "description": "In UX design, making something incidental refers to subtly introducing a feature or element while the user is engaged in a different, primary task. The intention behind this approach is to avoid interrupting the user's flow, prevent them from feeling overwhelmed, and make the discovery of that feature feel more natural and serendipitous.\n\nBenefits of Making It Incidental\n--------------------------------\n\n*   **Less Overwhelming:** Users are not bombarded with too much information at once, as an incidental introduction happens when they are already engaged in another task.\n*   **Avoids Distractions:** It doesn't disrupt the flow of the application, allowing users to maintain focus on their original task.\n*   **Increases User Engagement:** As users chance upon a feature or element that they possibly need or find useful in the future, this may deepen their connection with the product.\n\nTechniques to Make it Incidental\n--------------------------------\n\n*   **Progressive disclosure:** Reveal information or features when relevant, in the context of the user's current task.\n*   **Guided interactions:** Introduce features while users are actively engaged in tasks, where the discovery is an organic part of the interaction.\n*   **Contextual hints:** Provide subtle cues or suggestions for users that signal the presence of additional features, which can be used when needed.\n\nRemember, the key to making something incidental is to strategically place it within the user journey, so that it feels like a natural and seamless discovery. This approach can help create delightful and efficient user experiences.",
+    "links": []
+  },
+  "ZufrLRNkMoJ4e2T-vWxCR": {
+    "title": "Automate the Act of Repetition",
+    "description": "As a UX designer, one of your main goals is to simplify and streamline user interactions. Often, users are required to perform repetitive tasks, which can lead to frustration and decrease efficiency. To enhance the user experience and ensure smooth sailing, it's essential to reduce or eliminate the need for repeated actions by automating repetitive tasks wherever possible.\n\nBenefits of Automation\n----------------------\n\nWhen properly implemented, automation can:\n\n*   Save time: By cutting down on repeated actions, users can complete tasks more quickly, increasing productivity.\n*   Reduce errors: Automating tasks can minimize human error and ensure that actions are completed correctly every time.\n*   Improve user satisfaction: Reducing tedious tasks can lead to a more positive user experience and increase user retention.\n\nStrategies for Automation\n-------------------------\n\nAs a UX designer, consider the following strategies to automate repetitive tasks:\n\n*   **Pre-fill forms**: Auto-fill form fields with the information that the user has entered previously or is likely to enter, such as their name, email address, or phone number. This can save users time and effort in filling out forms.\n*   **Remember user preferences**: Store user settings and preferences, such as preferred language, currency, or theme, so that users don't have to set them again every time they visit your site or app.\n*   **Smart suggestions**: Implement predictive text or auto-suggestions based on user input or past behavior. For example, when typing search queries or filling out forms, users may appreciate suggestions to help them complete their task quickly.\n*   **Batch actions**: Allow users to perform actions, like selecting or deleting items, in groups rather than individually. This can significantly reduce the number of clicks and time required to complete the task.\n*   **Keyboard shortcuts**: Provide keyboard shortcuts for common actions, enabling users to perform tasks without using a mouse or touch interactions. This can be particularly helpful for power users or users with accessibility needs.\n\nBy automating acts of repetition in your design, you can enhance the user experience, reduce frustration and improve overall satisfaction. Be mindful of your users' needs, analyze the repetitive tasks they may encounter, and implement effective automation techniques to create a seamless, efficient, and enjoyable experience.",
+    "links": []
+  },
+  "y6CqgqTvOt-LrvTnPJkQQ": {
+    "title": "Make or Change Habits",
+    "description": "Making or changing habits is an essential aspect of UX design that focuses on helping users adopt new behaviors and patterns. In order to create a lasting impact, designers need to implement strategies that will facilitate the formation or modification of habits for users. Below, we've outlined some key components to consider when creating or changing habits in UX design.\n\n*   **Identify user goals and barriers**: First and foremost, determine the end goal of your users and identify any obstacles that may inhibit them from achieving their desired outcome. By addressing these barriers through design, you can help users overcome challenges and form new habits.\n    \n*   **Utilize triggers**: Triggers, or prompts, can be incorporated into a design to remind users to take specific actions. These can be visual (e.g., a button), auditory (e.g., a notification sound), or contextual (e.g., a reminder based on time or location). Including triggers in your design can improve habit formation for users.\n    \n*   **Simplify the process**: Break down complex tasks or goals into smaller, more manageable steps to make it easier for users to form new habits. This way, users will feel less overwhelmed and will be more likely to stick to the desired behavior.\n    \n*   **Incorporate feedback and rewards**: Positive reinforcement is a powerful tool that can be used to encourage new habits. Provide users with immediate feedback on their progress and offer rewards (e.g., badges, points, etc.) for completing tasks or achieving goals. This will motivate users and help them stay engaged with your product.\n    \n*   **Leverage social influence**: Humans are social creatures by nature; we tend to follow the behaviors and trends of our peers. Incorporate social elements into your design to promote healthy competition and create a sense of community among users, further incentivizing them to form new habits.\n    \n*   **Iterate and improve**: Finally, always strive for improvement by continuously analyzing and iterating on your designs. Gather user feedback to identify areas where users may be struggling to form or maintain new habits, adjusting your design accordingly.\n    \n\nBy understanding the principles of habit formation and incorporating these strategies into your UX design process, you can help users adopt new behaviors more easily and create lasting change.",
+    "links": []
+  },
+  "S2TgqNDjvmcJTaXncM09u": {
+    "title": "Help user Avoiding the Cue",
+    "description": "In UX design, it's important to understand the existing behaviors and habits of your users. One aspect of this process is helping users avoid the cues that trigger unwanted or unnecessary actions. Cues are the signals or prompts that lead users to perform specific behaviors. By identifying and mitigating these cues, you can effectively guide users to have a more streamlined and efficient user experience.\n\nHere are some strategies to help users avoid the cue:\n\n*   **Identify the cue**: The first step is to recognize the cues that lead to unwanted behaviors. This can be achieved by observing users, conducting usability testing or through user feedback.\n    \n*   **Remove the cue**: Once the cue is identified, remove or minimize it to prevent users from performing the undesired action. This could be achieved by redesigning the interface, altering the layout or adjusting the visual hierarchy of elements.\n    \n*   **Provide alternatives**: Offer alternative actions or paths for users to take in order to achieve their goal without encountering the unwanted cue. Make sure these alternatives are easily accessible and have clear call-to-action elements.\n    \n*   **Educate users**: Sometimes, simply removing a cue isn't enough. In these cases, it's important to educate your users about the new optimal way to perform a task. This can be done through in-app guides, tutorial videos or tooltips.\n    \n*   **Monitor user behavior**: Continuously assess user behavior and feedback to ensure that the unwanted cues are no longer causing problems. Be prepared to make further adjustments if necessary, and consider implementing A/B testing to optimize your solution.\n    \n\nBy helping users avoid unwanted cues, you'll create a more seamless user experience, leading to increased user satisfaction and a more effective product overall.",
+    "links": []
+  },
+  "_C-55tciBzc6_Kyk6272k": {
+    "title": "Replace the Routine",
+    "description": "In the UX design process, understanding and working with existing user behavior is crucial. One key aspect of this is the concept of \"replace the routine\". This involves observing and analyzing the current habits and routines of your users, and then designing your product around it.\n\nReplacing the routine in UX design is about finding more efficient, delightful, and engaging ways for users to complete their tasks. You should not look to force a completely new set of behaviors upon your users but instead improve their experience by offering a better alternative to their existing habits.\n\nConsider the following points when replacing the routine:\n\n*   **Understand the user's context**: Study the users’ life cycle and create personas to better comprehend their . This helps you identify their preferences, pain points, and habits, which in turn enables the creation of a meaningful and effective design.\n    \n*   **Identify the existing routine**: Analyze the current habits and routines of your users. What are the steps they are used to taking in order to complete the task? This information will be vital in designing a product that smoothly replaces their existing routine with an improved one.\n    \n*   **Design an improved routine**: Create a new user flow that achieves the same goal but in a manner that is more efficient, simpler, and more intuitive for the user. This new routine should leverage the knowledge you have gained about your users and their preferences.\n    \n*   **Test the new routine**: The importance of usability testing cannot be overstated. Validate your design by having real users test it out, and gather feedback to identify any areas that can be further optimized. Ensure that the new routine actually improves upon the existing one and doesn't create any new confusion.\n    \n*   **Iterate and refine**: UX design is an ongoing process. Continuously refine and optimize the new routine based on the user feedback and changing user behavior trends.\n    \n\nBy adopting the \"replace the routine\" approach in your UX design, you can provide your users with a better experience that aligns with their existing behaviors, while also introducing new efficiencies and possibilities. Doing so increases user satisfaction, promotes adoption, and ultimately leads to happier, loyal users.",
+    "links": []
+  },
+  "0MbrHG-VDrdZqQ0jWtiDo": {
+    "title": "Use Consciousness to Intefere",
+    "description": "In UX design, understanding the existing behavior of users is essential to create a seamless and efficient user experience. One way to obtain this understanding is through the concept of \"use consciousness to interfere.\" This method involves taking a conscious and deliberate approach to observing and analyzing user behavior, in order to identify problems or areas of improvement, and then designing solutions based on these insights.\n\nHere's a brief summary of how to use consciousness to interfere in UX design:\n\n*   **Observation**: Start by observing users in their natural environment, using your product or interacting with similar products. This will give you valuable insight into their habits, preferences, and challenges.\n    \n*   **Analysis**: Next, analyze the data you've collected from your observations. Identify patterns, problems, and opportunities for improvement. This might involve breaking down tasks into smaller components, examining specific user flows, or comparing different user groups.\n    \n*   **Empathy**: Develop a deep empathy for your users, understanding their needs, problems, and motivations. This will help you prioritize features and improvements, and design solutions that genuinely address their needs.\n    \n*   **Experimentation**: Generate multiple ideas and possible solutions based on your analysis and empathic understanding of users. Test these ideas through rapid prototyping and user testing to get feedback and iterate on your designs.\n    \n*   **Measure Impact**: Continuously measure the impact of your design changes by monitoring user behavior and key performance indicators (KPIs). This will help you understand the effectiveness of your interventions and inform future design decisions.\n    \n\nBy using consciousness to interfere in the UX design process, you gain a deeper understanding of user behavior, enabling you to create more intuitive, engaging, and effective user experiences.",
+    "links": []
+  },
+  "d1dXGCHmMF2EFpL5yKVJA": {
+    "title": "Mindfulness to Avoid Acting on the Cue",
+    "description": "Mindfulness is a powerful technique that can help designers and users alike to avoid acting on the cues that trigger unwanted behaviors. Mindfulness practices can strengthen one's self-awareness and self-regulation skills, allowing individuals to recognize cues and make more conscious decisions about their actions.\n\nHow to practice mindfulness in UX design\n----------------------------------------\n\n*   **Be present:** When designing or using a product, focus on the task at hand and avoid multitasking. By fully engaging in the moment, you'll be more aware of the cues that may trigger unwanted behaviors.\n    \n*   **Observe without judgment:** Take note of any compulsions or urges that arise while interacting with a product, but don't judge them as good or bad. Simply acknowledging their existence can help you understand your responses and make better choices in the future.\n    \n*   **Pause and reflect:** When you notice a cue, take a moment to pause and evaluate your options. Consider whether the action you're about to take is aligned with your goals or if it's something you'd like to change.\n    \n*   **Respond with intention:** Once you've reflected on your options, make a conscious decision about your next action. This may mean going through with the original behavior, choosing a more desirable alternative, or refraining from acting entirely.\n    \n\nIncorporating mindfulness techniques into your designs\n------------------------------------------------------\n\nIn addition to practicing mindfulness personally, consider how you can create designs that encourage users to be more mindful and avoid acting on unwanted cues.\n\n*   **Design for minimal distractions:** Aim to reduce visual clutter, unnecessary alerts, and anything that might pull users' attention away from the present moment.\n    \n*   **Provide clear action cues:** Make sure that cues for desired actions are clear and easy to understand, allowing users to make more conscious decisions about their actions.\n    \n*   **Support user reflection:** Consider incorporating features that prompt users to reflect on their actions, such as goal-setting or progress tracking tools, which can encourage more mindful decision-making.\n    \n\nBy fostering mindfulness in both your design process and your end product, you can create UX experiences that help users better navigate their interactions with technology, avoiding unwanted behaviors and promoting healthier habits.",
+    "links": []
+  },
+  "B0gg7Z5JL9m9Srb89KcN5": {
+    "title": "Crowd Out Old Habit with New Behavior",
+    "description": "One of the most effective ways to change users' existing behavior and improve their experience with your product is by replacing old habits with new ones. This method involves identifying the actions and habits that users currently perform and finding ways to replace them with more efficient, healthy, or enjoyable behaviors.\n\nIdentifying Old Habits\n----------------------\n\nFirst, start by observing and researching how users interact with your product or a similar product to understand their current behavior. This can be done through user interviews, surveys, or by analyzing collected usage data. Try to identify the habits that are no longer useful, might be frustrating or time-consuming, or can be significantly improved.\n\nDesigning New Behaviors\n-----------------------\n\nAfter identifying the habits that need to be replaced, focus on designing new behaviors that are more efficient, enjoyable or beneficial to users. To do this, consider employing the following strategies:\n\n*   Make the new behavior simple: Ensure the new behavior is easy to understand and perform so that users can naturally adopt it.\n*   Use visual cues: Incorporate visual cues in your design to subtly remind users of the new behavior they should perform.\n*   Positive reinforcement: Encourage users to adopt the new behavior by providing feedback, rewards or incentives.\n*   Progressive onboarding: Gradually introduce users to the new behavior, giving them sufficient time to adjust and understand its benefits.\n\nImplementation and Testing\n--------------------------\n\nOnce you have designed the new behavior, it's time to implement it in your product and test its effectiveness. This testing can be done through A/B testing, focus groups, or beta users who can provide valuable feedback.\n\nMonitor user behavior and analyze data to determine if the new behavior is successfully replacing the old habit. If needed, iterate on your design to make necessary improvements, and continue tracking user behavior until the new habit is well-established.\n\nIn summary, crowding out old habits with new behaviors is an effective method of improving user experience in your product. By identifying existing behaviors that need change, designing new habits that are beneficial to users, and constantly testing and iterating, you can ensure a successful transition for your users and an overall improved UX.",
+    "links": []
+  },
+  "w_QWN80zCf1tsVROeyuvo": {
+    "title": "Behavior Change Strategies",
+    "description": "Behavior change strategies are techniques that aim to help users adopt new behaviors or break existing ones to achieve specific goals, such as healthier lifestyles or improved productivity. In UX design, these strategies are applied to design elements and features within digital products or services to motivate and support users in making lasting changes in their actions.\n\nHere are some key behavior change strategies often employed in UX design:\n\n*   **Goal Setting:** Asking users to set specific, measurable, achievable, relevant, and time-bound (SMART) goals can help them focus their efforts and track their progress.\n    \n*   **Feedback and Rewards:** Providing users with real-time feedback on their progress and rewarding them with positive reinforcement (e.g., badges or points) can increase motivation and engagement.\n    \n*   **Social Comparisons:** Facilitating comparisons between users or groups can tap into social influence and normative pressure, encouraging behavior change through competition or collaboration.\n    \n*   **Reminders and Prompts:** Sending timely reminders or prompts can help reinforce desired behaviors by making them more salient and top of mind.\n    \n*   **Choice Architecture:** Structuring the presentation of options, defaults, and information can nudge users towards better decisions without restricting their freedom of choice.\n    \n*   **Modeling and Stories:** Demonstrating desired behaviors through role models, cases, testimonials or stories can provide inspiration and social proof that change is possible and desirable.\n    \n*   **Progressive Disclosure:** Gradually introducing advanced features, content or challenges can help users build their skills and confidence, preventing them from feeling overwhelmed or disengaged.\n    \n*   **Personalization and Tailoring:** Customizing content or recommendations based on a user's preferences, history or characteristics can make interventions more relevant and effective.\n    \n\nBy incorporating these behavior change strategies in your UX design, you improve the chances of users successfully adopting the desired behaviors, which can ultimately lead to a more positive and effective user experience.",
+    "links": []
+  },
+  "q1WX2Cp4k4-o1T1vgL8FH": {
+    "title": "Understanding the Product",
+    "description": "Before diving into UX design, it's crucial to have a thorough understanding of the product you're working on. This doesn't only mean understanding its core features and functionalities, but also being aware of the underlying business goals and the target audience.\n\nKey Components of Understanding the Product\n-------------------------------------------\n\n*   **Business Goals:** Understand the objectives and goals of the company or client for whom you're designing. Are they looking to increase their user base, boost sales, or provide a seamless experience? Knowing the goals will shape your design decisions and ensure that your UX design aligns with the company's vision.\n    \n*   **Target Audience:** Clearly identify the target audience or user persona for the product. Understand their demographics, pain points, and preferences. This insight will help you design an experience tailored to their needs and expectations, resulting in higher engagement and satisfaction.\n    \n*   **User Journey:** Map out the user journey for the product, from the initial point of contact to their ultimate goal. This process will help you identify areas where users might encounter difficulties or confusion, and it will provide you with a blueprint for crafting a smooth user flow.\n    \n*   **Competitor Analysis:** Evaluate the strengths and weaknesses of competitors' products to identify opportunities for differentiation and improvement, as well as to glean inspiration from successful or innovative designs.\n    \n*   **Brand Consistency:** Familiarize yourself with the company's brand identity, including colors, fonts, and themes. It's important that your design aligns with the brand in order to create a cohesive and recognizable user experience.\n    \n\nStrategies for Understanding the Product\n----------------------------------------\n\n*   **Interview Stakeholders:** Engage with stakeholders, such as product managers and business owners, to gain insights into their goals, requirements, and expectations for the project.\n*   **User Research:** Conduct user interviews, surveys, or focus groups to gather information on user needs, pain points, and preferences.\n*   **Involve Users in Design:** Involve users in the design process through activities like participatory design or usability testing, where users can provide feedback on prototypes and designs.\n*   **Stay Updated on Industry Trends:** Keep yourself informed on current trends in UX design and technology to ensure your design remains relevant and up-to-date.\n\nBy investing time in understanding the product from the business, user, and competition perspectives, you'll be better equipped to create a successful and impactful UX design.",
+    "links": []
+  },
+  "7J8F9dn1jGaVlhLVVRPrG": {
+    "title": "Target Outcome",
+    "description": "The target outcome is a clear, measurable, and time-bound objective that your product aims to achieve. It defines the desired results for your users and becomes the focal point for the entire product design process. A well-defined target outcome ensures that your UX design is aligned with your users' needs and your business goals.\n\nHere are a few key elements to consider when defining your target outcome:\n\n*   **User needs**: Focus on the main problems and needs your users have, and how your product can address them. It's crucial that your target outcome is directly linked to user satisfaction.\n    \n*   **Specific and measurable**: Your target outcome should be specific enough to guide your design decisions and measurable, so you can assess whether you've achieved the desired results. For example, instead of aiming for \"improving user engagement,\" a target outcome could be \"increase the average time spent on the app by 10% within 3 months.\"\n    \n*   **Realistic**: Your target outcome should be achievable given your current resources, team, and product. Setting overly ambitious objectives may lead to frustration and a lack of focus in your design process.\n    \n*   **Time-bound**: Establish a clear timeline for achieving your target outcome. A deadline helps keep the team focused and on track and allows you to evaluate your progress along the way.\n    \n\nTo sum up, defining a clear target outcome is a critical step in the UX design process, as it guides decision-making and helps ensure that your product delivers true value to your users. By focusing on user needs, making your target outcome specific and measurable, setting realistic goals, and establishing a timeline, you can ensure that your product's UX design is aligned with both user needs and business objectives.",
+    "links": []
+  },
+  "FRn2MaR0-ehSD3zmwXcCI": {
+    "title": "Target Actor",
+    "description": "A **Target Actor** refers to the specific user or group of users for whom a product or service is designed to cater. These users have particular needs, goals, and expectations from the product, and understanding their characteristics is essential for creating a UX design that provides them with an optimal user experience. The term is often used interchangeably with \"target audience\" or \"user persona.\"\n\nWhen designing for a target actor, it is crucial to consider the following factors:\n\n*   **Demographics**: Age, gender, education, occupation, and location play a significant role in determining user preferences and behavior. These factors help designers create a relatable and appropriate user experience.\n    \n*   **Psychographics**: This refers to the psychological aspects of the target actor, such as their attitudes, motivations, and personality traits. Understanding these aspects helps designers align the product with users' mental models and expectations.\n    \n*   **Goals and Pain Points**: Identifying the problems target actors face and their goals helps designers create solutions that address their specific needs. This information also helps in prioritizing features and functionalities within the product.\n    \n*   **Technology proficiency**: Users' familiarity with devices and applications greatly impacts their expectations and behavior while using a product. Designers must take into account their target actor's proficiency with technology to ensure a smooth and frustration-free user experience.\n    \n\nTo effectively design for target actors, user research methods such as interviews, surveys, and usability tests can be employed to gather data and insights. This information helps designers create accurate user personas and make informed design decisions tailored to the needs of the target actors. By keeping the target actors at the forefront throughout the design process, you will ultimately create a more satisfying and successful product experience.",
+    "links": []
+  },
+  "AXn-N15U_z4OagClNoXrW": {
+    "title": "Target Action",
+    "description": "Target action is a fundamental concept in designing user experiences that focuses on the primary goal a user wants to achieve while interacting with your product. It refers to the specific action or task users are aiming to complete, which helps them solve their problem or fulfill a need.\n\nUnderstanding the target action helps you create a more streamlined and effective design by optimizing the interface, elements, and navigation around users' primary goals. Here are the key aspects of target action:\n\n*   **Identify the Target Users:** To begin with, know your audience. Consider demographics, interests, and behaviors to get a clear picture of who your target users are. This will help you align the product design with users' needs and expectations.\n    \n*   **Determine User Goals:** Understand what users want to achieve with your product. Analyze their needs, preferences, pain points, and habits to identify their primary goals.\n    \n*   **Establish Clear Actions:** Based on user goals, determine the most critical actions they need to perform within your product. Simplify these actions by making them clear, obvious, and easy to access.\n    \n*   **Design for Success:** Prioritize target actions in your design. Focus on providing a clear path and guiding users towards attaining their goals by emphasizing essential elements, simplifying decision-making, and minimizing distractions.\n    \n*   **Validate with Testing:** Verify whether your design indeed supports users in achieving their target actions by conducting usability tests. Gather user feedback, analyze the results, and iterate the design until users can effortlessly complete their primary goals.\n    \n\nBy incorporating the target action concept in your UX design process, you'll be able to create a more intuitive and user-centric product that effectively addresses users' primary goals and maximizes user satisfaction.",
+    "links": []
+  },
+  "s2KJ5kNv9UcnsP0QKIKQ7": {
+    "title": "Create User Personas",
+    "description": "User personas are fictional representations of your target users, created to help you understand their needs, behaviors, and goals. They are essential in UX design as they help your team stay focused on user needs and maintain empathy for the user throughout the design process. Here's a brief overview of how to create user personas:\n\n*   **Gather User Data**: Conduct user research through methods such as interviews, surveys, and observations to collect data about your target users. This will provide you with valuable insights and help you identify patterns in user behavior.\n    \n*   **Identify Key Characteristics**: Analyze the collected data to identify common characteristics, such as demographics, goals, motivations, and pain points. These characteristics will form the foundation of your personas.\n    \n*   **Create Persona Profiles**: Based on the identified characteristics, create 3-5 distinct user personas. Each persona should have a name, a picture (to help humanize them), and details such as age, occupation, background, and a brief description of their typical day.\n    \n*   **Define User Goals and Scenarios**: List the primary, secondary, and tertiary goals of each persona, along with realistic scenarios in which they interact with your product or service. This will help you understand how different users approach your product and what they expect from it.\n    \n*   **Share and Refine**: Share your personas with your team and gather feedback. Make any necessary changes to ensure that the personas accurately represent your target users.\n    \n\nRemember, user personas are not static, and should be updated as you gather more user data and insights. Keep them in mind throughout the design process, and always consider their needs and goals when making design decisions.",
+    "links": []
+  },
+  "SGO9hHju49_py0n0ASGBe": {
+    "title": "Business Model Canvas",
+    "description": "The **Business Model Canvas** is a strategic management and visual representation tool that allows you to describe, design, challenge, and pivot your existing business model. Developed by Alexander Osterwalder and Yves Pigneur, it helps organizations to understand how they create, deliver, and capture value. The canvas is divided into nine building blocks, which represent the essential elements of a business model:\n\n*   **Customer Segments (CS):** These are the target groups your business aims to serve, such as specific users, organizations, or market segments.\n*   **Value Propositions (VP):** The unique combinations of products and services that create value for your customer segments. It describes the reasons why customers choose your product or service over your competitors'.\n*   **Channels (CH):** The means by which your company communicates, delivers, and distributes its value propositions to the customers. This block includes both physical (e.g., stores) and virtual (e.g., online) channels.\n*   **Customer Relationships (CR):** The type of relationships your business establishes and maintains with its customer segments, such as personal assistance, self-service, or automated services.\n*   **Revenue Streams (RS):** The ways in which your company generates revenue from each customer segment, such as through sales, subscriptions, or advertising fees.\n*   **Key Resources (KR):** The most important assets needed to make your business model work, including physical, financial, intellectual, and human resources.\n*   **Key Activities (KA):** The primary actions your company must perform to deliver its value propositions, reach its customer segments, and maintain customer relationships. These can involve production, problem-solving, or service provision.\n*   **Key Partnerships (KP):** The network of suppliers, partners, and allies that help your business execute its key activities, optimize resources, and reduce risks.\n*   **Cost Structure (CS):** The major expenses associated with operating your business model, such as fixed and variable costs, economies of scale, and cost advantages.\n\nWhen designing or analyzing an existing business model, the Business Model Canvas enables you to visually map out all these critical components and understand how they are interconnected. By understanding your current business model, you can identify weaknesses, opportunities for improvement, and potential pivots to enhance the overall user experience and the success of the business.",
+    "links": []
+  },
+  "sc8jJ_77CrkQuxIJYk28Q": {
+    "title": "Lean Canvas",
+    "description": "Lean Canvas is a streamlined, single-page approach to visualizing the essential components of a business model. It was developed by Ash Maurya as an adaptation of the Business Model Canvas, with a focus on helping startups and entrepreneurs quickly develop and communicate their business ideas. Lean Canvas helps you define your Unique Value Proposition (UVP), identify your target customers, and outline your strategy. Let's go through its key components:\n\nProblem\n-------\n\nStart by identifying the main problems your product aims to solve. Be specific, and try to focus on the most pressing issues faced by your target customers.\n\nCustomer Segments\n-----------------\n\nDefine your target audience. Be as specific as possible, describing the types of customers who would benefit most from your product or service.\n\nUnique Value Proposition (UVP)\n------------------------------\n\nClearly articulate the unique value your product or service offers to your target customers. Your UVP should be distinctive and competitive, differentiating you from other solutions in the market.\n\nSolution\n--------\n\nList the key features, functionalities, or aspects of your product that address the identified problems, and align with your UVP.\n\nChannels\n--------\n\nOutline the various methods through which you plan to reach your target customers, such as social media, search engine optimization (SEO), email campaigns, or paid advertising.\n\nRevenue Streams\n---------------\n\nIdentify the ways you plan to generate income from your product or service. This could include sales, subscriptions, sponsorships, affiliate partnerships, or other revenue-generating channels.\n\nCost Structure\n--------------\n\nList your main costs and expenses associated with building, launching, and maintaining your product, including development, marketing, operations, and support.\n\nKey Metrics\n-----------\n\nDetermine the indicators you'll use to track your performance and gauge the success of your product. Metrics could include sales, user engagement, customer satisfaction, or any other relevant success indicators.\n\nUnfair Advantage\n----------------\n\nIdentify and describe any unfair advantages your product or business may have over your competitors. This could include unique expertise, proprietary technology, or strategic partnerships.\n\nBy completing a Lean Canvas, you'll have a clear and concise overview of your business model, allowing you to refine your concept, focus on what matters most, and communicate your vision to team members, investors, and customers. It's a powerful tool that can be an excellent starting point for any entrepreneur or startup looking to create a successful UX design.",
+    "links": []
+  },
+  "GI06-DbGyJlQXq5Tyi-aH": {
+    "title": "Business Model Inspirator",
+    "description": "A Business Model Inspirator is a tool or method that helps you to generate new or creative ideas for the strategic, operational, and financial aspects of a business. It helps entrepreneurs, startups, and established companies to explore different ways of designing or improving their business models by drawing inspiration from various sources.\n\nSome key aspects of Business Model Inspirators include:\n\n*   **Analyze Successful Models**: Look at successful companies from diverse industries to identify the core elements that made their business models successful. Understanding these elements can spark ideas for your own business model.\n    \n*   **Cross-Pollination**: Combine elements from various industries and business models to create an innovative approach that suits your specific domain. This process can lead to the development of a unique value proposition and competitive advantage.\n    \n*   **Experimentation**: Test different ideas to find the most feasible and scalable business model by iteratively prototyping, validating, and refining the model based on user/client feedback.\n    \n*   **Futuristic Thinking**: Stay aware of emerging trends, technologies, and structural changes in society that might affect your industry or target market. Use foresight to adapt your business model to future opportunities and challenges.\n    \n*   **Adaptability**: Be ready to pivot or evolve your business model based on changing market dynamics, user preferences, competitive forces, and other external factors. Developing a flexible business model is crucial to ensure long-term success and sustainability.\n    \n\nImplementing a Business Model Inspirator can contribute to the creation of a more innovative and robust UX design, ultimately leading to enhanced customer experiences, increased revenue, and long-term success for your brand.",
+    "links": []
+  },
+  "HUZ5n2MRHzQPyjwX2h6Q4": {
+    "title": "Competitor Analysis",
+    "description": "**Competitor Analysis**\n\nCompetitor analysis is a crucial part of UX design, especially when dealing with new business models. It involves evaluating your competitors within your industry, understanding their strategies, strengths, and weaknesses, and comparing them with your own offerings.\n\nBy conducting a thorough competitor analysis, you can gain valuable insights into the market and potentially discover opportunities to differentiate yourself from the competition. Here's a brief overview of how to perform a competitor analysis:\n\n*   **Identify your competitors:** Start by listing all the companies that offer a similar product or service within your target market. This may include direct competitors (who offer similar products and services) and indirect competitors (who offer alternative solutions to the same problem).\n    \n*   **Analyze their products and services:** Investigate your competitors' products and services by studying their features, benefits, and user experiences. Look for any gaps in their offerings or areas where you might have an advantage.\n    \n*   **Study their websites and apps:** Evaluate your competitors' digital platforms, such as their websites, mobile apps, or software. Assess their usability, visual design, content, and overall user experience.\n    \n*   **Evaluate their marketing strategies:** Analyze their communication channels and promotional activities, such as email campaigns, social media presence, and content marketing efforts. Take note of any strategies that seem particularly successful or unique.\n    \n*   **Examine customer reviews and feedback:** Collect and analyze customer reviews and feedback from popular review platforms, social media, and forums. This information can help you understand common pain points and areas for improvement in your competitors’ offerings.\n    \n*   **Identify opportunities and niches:** Based on your research, identify weaknesses in your competitors' strategies or markets, where potential opportunities exist for your business to be successful.\n    \n*   **Benchmark your own offerings:** Compare your products and services with those of your competitors. Identify your unique selling points and assess if your offerings cater to the needs of your target audience in a way that sets you apart from the competition.\n    \n\nRemember that competitor analysis is not a one-time task. Instead, it should be an ongoing process that helps you stay up-to-date with the trends and changes within your industry, allowing you to make informed decisions about your UX design and overall business strategy.",
+    "links": []
+  },
+  "F9gpGTRwXq08jNo5pPKm6": {
+    "title": "Five Forces Model",
+    "description": "**Five Forces Model**\n\nThe _Five Forces Model_ is a strategic framework developed by Harvard Business School professor Michael Porter. It is designed to analyze the competitive environment and help businesses understand the factors that influence competition, profitability, and overall industry attractiveness. This model is essential in UX design as it helps you identify opportunities, make informed decisions, and ultimately design products that satisfy users' needs and preferences.\n\nThe Five Forces Model consists of five components:\n\n*   **Competitive Rivalry:** This component addresses the intensity of competition among existing competitors within the industry. Factors affecting competitive rivalry include the number of competitors, diversity of competitors, the level of growth and demand, and barriers to exit. Knowing your competitors is crucial in UX design, as it guides you in creating features and improvements that build a competitive edge.\n    \n*   **Threat of New Entrants:** The possibility of new entrants entering the market impacts the competitive landscape. This force is determined by factors such as capital requirements, economies of scale, switching costs, and access to distribution channels. To remain competitive as a UX designer, you must continuously gauge potential threats and evolve your strategy to create and maintain a unique value proposition.\n    \n*   **Threat of Substitutes:** This force examines how easily users can switch between products or services that offer similar benefits. Factors affecting the threat of substitutions include the availability of alternatives, the price-performance ratio, and the perceived level of product differentiation. It is crucial to understand these factors and design your product in a manner that sets it apart, making it difficult for users to find substitutes.\n    \n*   **Bargaining Power of Suppliers:** This component evaluates the influence suppliers have over the price and quality of goods and services in your industry. Factors impacting bargaining power include the number of suppliers, availability of substitute inputs, brand strength, and cost structure. In UX design, it's essential to consider how the supplier landscape impacts product development and identify ways to work closely with suppliers to create valuable partnerships.\n    \n*   **Bargaining Power of Buyers:** Lastly, this force examines the degree of control customers have over your product's price, features, and overall quality. Factors that affect buyer power include market size, consumer information availability, product differentiation, and price sensitivity. In UX design, it's crucial to align your product with user expectations and preferences, ensuring they perceive it as valuable and are less likely to seek alternatives.\n    \n\nTo effectively use the _Five Forces Model_ in UX design, it's essential to research and understand these forces in your industry, act on insights, and continually reassess your position as the competitive landscape evolves. By doing so, you'll create a robust and sustainable UX strategy that satisfies both user needs and market demands.",
+    "links": []
+  },
+  "XiEn1OGFY1bMCoB0Pk8N_": {
+    "title": "SWOT Analysis",
+    "description": "A SWOT analysis is a useful tool for assessing the strategic position of a company or product. It stands for:\n\n*   **Strengths**: Identify the internal factors that give an advantage over the competition. Examples include a strong brand presence, skilled workforce, or access to unique resources.\n*   **Weaknesses**: These are internal factors that may hinder your business growth or success. Examples include limited resources, outdated technology, or poor management.\n*   **Opportunities**: These are external factors that can be seized to grow or improve the business. Examples include an expanding market, technological advancements, or potential partnerships.\n*   **Threats**: These are external factors that may negatively impact the business, such as competitors, government regulation, or economic instability.\n\nPerforming a SWOT analysis can help you identify and prioritize the areas that need improvement, capitalize on opportunities, and address significant threats before they become a crisis. This analysis not only provides valuable insights into your current situation but also helps you prepare for the future by assessing risks and potential areas for growth.\n\nTo ensure a comprehensive SWOT analysis, follow these steps:\n\n*   **Gather Relevant Information**: Begin by collecting data on internal strengths and weaknesses, such as financial performance and organizational structure. For the external analysis, examine market trends, competitor strategies, and other factors impacting the business environment.\n*   **Notable Factors**: List down factors impacting your business's performance and classify them under strengths, weaknesses, opportunities, and threats.\n*   **Evaluate and Prioritize**: Assess the importance of each item within the SWOT matrix, considering both its impact on the business and the resources required to address it.\n*   **Develop Strategies**: Use the SWOT results to create effective strategies that leverage strengths, address weaknesses, capitalize on opportunities, and mitigate threats.\n*   **Monitor Progress**: Continuously track the progress of your strategies, assessing their effectiveness and updating the SWOT analysis as required.\n\nIn summary, a SWOT analysis can serve as an excellent starting point in creating a robust UX design strategy. By understanding the internal and external factors influencing your business, you can make informed decisions while designing user experiences that resonate with your target audience and promote business growth.",
+    "links": []
+  },
+  "r6D07cN0Mg4YXsiRSrl1_": {
+    "title": "Conceptual Design",
+    "description": "Conceptual design, often referred to as the \"big idea\" phase, is a fundamental step in the UX design process. It entails creating and defining an overarching concept, vision, or framework for a product or service.\n\nIn this stage, designers focus on gathering information, understanding the problem, and generating ideas that will guide the overall user experience. This includes defining goals, needs, and target users, as well as considering the broader context in which the solution will exist. The output should be a clear and concise direction for future design work and development.\n\nKey components of conceptual design include:\n\n*   **Problem Definition**: Identify and describe the core problem or challenge that your design aims to address. This should include insights from user research, business objectives, and a clear design goal.\n    \n*   **User Personas and Scenarios**: Develop representative user personas, providing demographic and behavioral information to help understand target user needs, motivations, and goals. Scenarios can then be created to illustrate how users might interact with the proposed solution in various contexts.\n    \n*   **Information Architecture**: Define the high-level structure of the product or service, organizing content and features in a way that is easy for users to understand and navigate. This helps ensure that information is presented clearly and consistently throughout the experience.\n    \n*   **Sketches and Wireframes**: Create rough sketches or wireframes to visualize key aspects of the user interface and explore various design alternatives. These early prototypes can help identify potential issues and guide future design decisions.\n    \n*   **Design Principles and Guidelines**: Establish a set of high-level principles and guidelines that will shape the design and serve as a foundation for further development. This may include aesthetic and functional criteria, as well as ensuring accessibility and usability.\n    \n*   **Iteration**: Continually refine and iterate on the initial concept, using feedback from user testing and stakeholder input to make informed design adjustments. This iterative approach allows for flexibility and adaptability as the project progresses.\n    \n\nUltimately, the goal of conceptual design is to create a coherent and engaging vision that meets user needs and aligns with business objectives. By investing time and effort into this foundational stage, designers can lay the groundwork for a successful and enjoyable user experience.",
+    "links": []
+  },
+  "tkbkpvHlWQeOnReanR8J7": {
+    "title": "User Stories",
+    "description": "User stories are an essential component of UX design, particularly during the process of creating a product backlog. They help to ensure that a product is designed with the end-user in mind, by capturing their needs, desires, and goals in a simple, concise format. In this section, we will explore what user stories are, why they are important, and how to create them.\n\nWhat are User Stories?\n----------------------\n\nA user story is a brief, informal description of a specific user's need or interaction with a product. They are written from the perspective of the user and typically follow this format:\n\n    As a [type of user], I want to [perform an action or achieve a goal] so that [reason or benefit].\n    \n\nFor example: As a busy parent, I want to be able to quickly find activities for my children in my local area, so that I can keep them entertained without spending hours searching the web.\n\nWhy are User Stories Important?\n-------------------------------\n\nUser stories serve several crucial functions in the UX design process:\n\n*   **Empathy**: By writing user stories, designers and product managers can better empathize with the users they are designing for, ultimately leading to more user-centered design decisions.\n*   **Communication**: User stories are an effective way to communicate the needs, goals, and concerns of target users to stakeholders, developers, and other team members.\n*   **Prioritization**: By considering user stories during the creation of a product backlog, teams can more effectively prioritize features and elements of the product that align with user needs.\n*   **Validation**: User stories provide a useful benchmark for validating design concepts and evaluating the effectiveness of the final product in meeting the needs of its users.\n\nHow to Create User Stories\n--------------------------\n\nWhen creating user stories, it is essential to keep the end-users in mind. Follow these steps to create effective user stories:\n\n*   **Identify User Personas**: Start by identifying the various user personas that will be interacting with your product. Consider their unique characteristics, needs, and goals.\n*   **Clarify Needs**: For each persona, clarify the specific needs that they have in relation to your product. Consider how your product will help them achieve their goals or fulfill their needs.\n*   **Write User Stories**: Using the provided format, write user stories that explicitly capture the needs of your identified personas. Be concise, clear, and specific.\n*   **Review and Refine**: Review the user stories with your team and stakeholders to ensure they accurately reflect user needs and goals. Refine them as necessary to maintain focus and clarity.\n\nIn conclusion, user stories are a powerful tool for creating a user-centered, empathetic design process. By effectively capturing user needs and goals, user stories help to guide product development and ensure that the final product is tailored to the end-users' desires.",
+    "links": []
+  },
+  "QNJ-LxfYtR8lbnmuy2Qm9": {
+    "title": "In general, keep it short and simple",
+    "description": "The principle of \"Keep it short and simple\" (also known as the KISS principle) is an essential aspect of UX design. It is about creating user interfaces and product designs that are easy to understand, navigate and interact with, while minimizing unnecessary elements and complexities.\n\nHere are a few tips to implement the KISS principle in your UX design process:\n\n*   **Simplicity**: Limit the number of elements on the screen, and have a clear, straightforward layout. This makes it easier for users to focus on important information and reduces cognitive load.\n    \n*   **Clear Hierarchies**: Categorize and group information logically, making sure that the most essential information is presented first. This helps users quickly understand the structure of your content.\n    \n*   **Minimal Clicks**: Aim to provide the shortest possible path for users to achieve their goal. Evaluate and eliminate any unnecessary steps or clicks to make the overall experience smooth and hassle-free.\n    \n*   **Consistency**: Keep key design elements and interactions consistent across your interface. This enables users to recognize patterns and anticipate behavior, which in turn makes it easier for them to learn and interact with your product.\n    \n*   **Content**: Write easy-to-understand and concise content that clearly communicates your message. Avoid jargon, and use clear language that is appropriate for your target audience.\n    \n*   **Visual Clarity**: Use simple and clean visual elements, such as icons, typography, and color schemes. Make sure your designs are legible and visually appealing without adding unnecessary clutter.\n    \n*   **Feedback**: Provide clear and timely feedback to users about the results of their actions. This helps them understand if they're on the right track or if they need to course-correct.\n    \n\nBy following the KISS principle, you can create a more efficient and enjoyable user experience, ultimately leading to increased user satisfaction and higher conversion rates.",
+    "links": []
+  },
+  "vAu2c45c7DgoRydHR2tvD": {
+    "title": "Make it easy to understand and complete",
+    "description": "In UX design, the key to creating a great user experience is making it easy for users to navigate, understand, and interact with your product or interface. Here are some important aspects to keep in mind while designing with the \"Make It Easy\" principle:\n\n*   **Clarity**: Keep the design and layout clean, with clear fonts and a simple interface. Avoid using too many different colors or elements that can clutter the screen and make it difficult for users to focus on their tasks.\n    \n*   **Consistency**: Keep a consistent design throughout the interface, by maintaining a standard pattern for elements, buttons, and symbols. This helps users understand the flow of your interface and what they need to do next.\n    \n*   **Intuitive Navigation**: Keep the navigation structure clear and easy to understand. Avoid using confusing labels or having too many layers of navigation that can make it difficult for users to find what they're looking for.\n    \n*   **Efficient Interaction**: Minimize the steps required to complete a task. Ensure that the user doesn't have to go through unnecessary steps or provide unnecessary input to achieve their goal.\n    \n*   **Error Prevention**: Help users minimize the chances of making errors by designing for error prevention. This can include things like disabling actions that aren't allowed, providing clear and concise instructions, or implementing user-friendly input fields.\n    \n*   **Flexibility**: Provide multiple ways for your users to complete tasks, so they can choose the approach that works best for their individual preferences and needs.\n    \n*   **Feedback**: Give users continuous feedback on the outcome of their actions. This can be through visual cues, sounds, and even haptic feedback. Providing feedback helps users understand what's happening and builds their confidence in the interface.\n    \n\nRemember, the easier it is for users to interact with your product, the more likely they are to enjoy using it, thus leading to a better overall user experience.",
+    "links": []
+  },
+  "8YePym3cQtoVY0DJQLllK": {
+    "title": "Make progress visible to user",
+    "description": "Making progress visible is an essential part of UX design, as it helps users understand where they are in a process, and it gives them a sense of control and achievement. In this section, we'll discuss the importance of making progress visible and provide some practical tips for incorporating this approach into your designs.\n\nImportance of Making Progress Visible\n-------------------------------------\n\nVisible progress can significantly impact user experience. It helps in:\n\n*   **Reducing user anxiety**: When users can see that they're making progress, they experience less anxiety and frustration.\n*   **Building engagement**: Progress indicators help users feel invested and engaged with a task or product.\n*   **Avoiding drop-offs**: When users can see the end of a process, they're more likely to complete it.\n\nTips for Making Progress Visible\n--------------------------------\n\nIncorporate these best practices into your UX design to make progress visible:\n\n*   **Use progress bars:** A simple and effective way to show progress is through progress bars. You can use them for linear processes, like form completion or steps in a tutorial.\n*   **Break tasks into manageable steps:** Chunking tasks into smaller steps makes them more manageable for users, and it allows users to see progress as they complete each step.\n*   **Give feedback on progress:** Provide clear feedback on the user's progress, such as a tick or checkmark, accompanying text, or a change of color.\n*   **Estimate time or effort:** Give users a sense of how long a task will take, or how much effort is involved, by showing time estimates or the number of steps involved.\n*   **Enable users to review progress:** Allow users to review their progress and easily navigate between completed steps if they need to make changes.\n\nBy making progress visible, you can provide users with a sense of accomplishment, reduce anxiety, and encourage engagement with your product. Keep this approach in mind during your UX design process to create more satisfying and user-friendly experiences.",
+    "links": []
+  },
+  "D3LVYuCDHD6-kU8GhXokf": {
+    "title": "Make progress meaningful to reward user",
+    "description": "When designing a UX, one crucial aspect to consider is creating a sense of progress and achievement for users. By making progress meaningful and rewarding users, you can enhance their overall experience, satisfaction, and engagement with your product or service. Here's a brief summary of some key points to consider when implementing this principle in your design.\n\nSet Clear Goals and Milestones\n------------------------------\n\nHelp users understand the objectives they need to achieve within your product or service. The goals should be specific, measurable, attainable, relevant, and time-bound (SMART). By providing well-defined milestones, users can easily visualize their progress and feel motivated to continue using your product.\n\nProvide Feedback\n----------------\n\nContinuously inform users about their progress and actions by providing feedback through visual cues, messages, notifications, or sounds. This will reassure them that they are on the right track and help maintain their engagement.\n\nCelebrate Achievements\n----------------------\n\nRecognize and celebrate user accomplishments, whether it's completing a task, reaching a new level, or mastering a new skill. This can be done through messages, badges, trophies, or other visual elements that give users a sense of achievement and recognition.\n\nPersonalize Rewards\n-------------------\n\nTailor rewards to cater to individual user preferences, taking into account their needs, desires, and achievements. This could mean offering different types of rewards or varying the difficulty levels to unlock them based on the user's past experiences with your product.\n\nEncourage Social Sharing\n------------------------\n\nLeverage the power of social networks to allow users to share their achievements and progress with friends, family, or other users. Providing incentives for sharing can also help enhance the feeling of accomplishment and increase the likelihood of continued engagement.\n\nGamification\n------------\n\nIncorporate gamification elements into your UX design to make progress and rewards more engaging and entertaining. Gamification techniques can include points, levels, leaderboards, and other game-like components that encourage users to invest time and effort in your product.\n\nBy making progress meaningful and rewarding for users, you can significantly enhance the overall user experience, foster user loyalty, and improve the chances of your product's long-term success. Always consider the unique needs and preferences of your target audience to customize your approach for the best results.",
+    "links": []
+  },
+  "94V3wUtZ0NMm_0Vb1pBju": {
+    "title": "Make successful completion clearly visible",
+    "description": "When designing user experiences, it's essential to ensure that users can easily recognize when they've completed a task or achieved their goal. This is important because it provides users with a sense of accomplishment and satisfaction; it also helps build trust in the digital product. Here are some tips to make successful completion clearly visible:\n\n*   **Visual feedback:** Provide clear visual cues (e.g., color changes, checkmarks, or other symbols) to indicate when a user has successfully completed a task. This reinforces the user's understanding that their actions have had the desired outcome.\n    \n*   **Success messages:** Display context-appropriate messages or confirmation screens to acknowledge that tasks have been successfully completed. For example, after submitting a form, show a success message containing a confirmation number and relevant next steps.\n    \n*   **Progress indicators:** Use progress bars or other indicators to help users track their progress towards task completion. This helps users understand how much work remains and can motivate them to continue working towards their goal.\n    \n*   **Transitions:** Utilize smooth animations and transitions when moving between different states or screens. This helps users recognize that they've successfully completed a task and are moving on to the next step.\n    \n*   **Accessible design:** Ensure that your success indicators and feedback are accessible to all users, including those with visual impairments. Use suitable text labels, alt text, and other accessibility features to guarantee that everyone can perceive and understand when they've completed a task.\n    \n\nBy incorporating these elements into your UX design, you will create a user experience that not only guides users through tasks efficiently but also provides them with the satisfaction of clearly visible successful completions. This, in turn, can lead to more enjoyable interactions with your digital product and improved user engagement.",
+    "links": []
+  },
+  "0KEqAjHFBjfmGA1bKzXuD": {
+    "title": "Customer Experience Map by Mel Edwards",
+    "description": "A **Custom Experience Map** is a powerful visual representation that helps designers and stakeholders understand the entire user journey. It captures the various touchpoints, interactions, and experiences a user goes through while using a product or service. This map can be created to suit the specific needs of your project or organization, giving you a comprehensive view of the user experience.\n\nKey Components of a Custom Experience Map\n-----------------------------------------\n\nBelow are some crucial components of an effective custom experience map:\n\n*   **User Persona**: This includes the demographics, goals, and pain-points of the target user, which helps in understanding the user's perspective throughout the journey.\n    \n*   **Stages**: The different logical steps or phases the user goes through during their interaction with the product or service.\n    \n*   **Touchpoints**: These are the specific interactions the user has with the product or service, such as clicking a button, opening an app, or talking to a customer representative.\n    \n*   **Channels**: These refer to the mediums or platforms through which the interactions take place, such as website, mobile app, email, or in-person.\n    \n*   **Emotions**: The emotional state of the user during each touchpoint, which can highlight areas of frustration or delight.\n    \n*   **Opportunities**: Areas where improvements can be made, new features can be introduced, or further research can be conducted to enhance the overall user experience.\n    \n\nBenefits of a Custom Experience Map\n-----------------------------------\n\nCreating a custom experience map offers several advantages for both designers and stakeholders:\n\n*   It helps identify the pain-points, gaps, or opportunities to improve user experience.\n*   It enables a better understanding of how users navigate and interact with the product or service.\n*   It facilitates the prioritization of UX design tasks and helps focus on high-impact areas.\n*   It promotes collaboration and communication across different team members within the organization.\n\nTips for Effective Experience Mapping\n-------------------------------------\n\nTo make the most of a custom experience map, consider the following tips:\n\n*   Involve different stakeholders and team members in the process to ensure diverse perspectives are taken into account.\n*   Use the map as a communication tool for sharing insights and findings with the team.\n*   Update the map as the product evolves or new data becomes available to keep it relevant and useful.\n*   Regularly review the map during design iterations to ensure user goals and pain-points are consistently addressed.\n\nBy leveraging the power of a custom experience map, UX designers can visualize and uncover valuable insights, which lead to more informed decisions and ultimately a better user experience.",
+    "links": []
+  },
+  "JCP5_jyvh9u7hxp379iW2": {
+    "title": "Simple Flowchart",
+    "description": "A simple flowchart is a useful deliverable in the UX design process that helps visually represent the flow of a user's journey through a website or an app. It's a diagrammatic representation of the user interactions and decision points, showcasing the steps they will take to achieve a specific goal.\n\nThis straightforward visual aid can assist the entire project team, including designers, developers, and stakeholders, to understand the overall structure and organization of the proposed design solution.\n\nKey Elements of a Simple Flowchart\n----------------------------------\n\n*   **Shapes**: Standard shapes like rectangles, diamonds, and ovals are utilized to indicate different actions or decisions in a flowchart. Each shape has a specific meaning, which aids in understanding the flow of the user interaction.\n*   **Lines and Arrows**: These are used to connect the various shapes and define the sequence of steps.\n*   **Labels**: Brief descriptions or texts inside the shapes describe the action, decision, or process represented by that particular shape.\n\nBenefits of Using Simple Flowcharts\n-----------------------------------\n\n*   **Shared Understanding**: Flowcharts are easy to read and understand, fostering a shared understanding between team members and stakeholders.\n    \n*   **Effective Communication**: They provide a clear way to communicate the steps involved in a process, making it easier for teams to discuss and collaborate.\n    \n*   **Identifying Potential Issues**: Flowcharts help identify potential bottlenecks or points of friction in a user's journey, enabling the team to address issues early in the design process.\n    \n*   **Documentation**: As a deliverable, flowcharts can serve as documentation, capturing the broader structure and steps in a process for future reference.\n    \n\nTo create a simple flowchart, start by listing all the essential steps and decisions in the user journey you want to document. Organize them sequentially and then use standard shapes and arrows to create the flowchart. Make sure to include annotations or labels to clarify the meaning of each shape.\n\nIn summary, a simple flowchart is a valuable UX deliverable that helps visualize user interactions and design solutions in an easy-to-understand format, facilitating better communication and collaboration within project teams.",
+    "links": []
+  },
+  "nccToz_0FUvHMJytpDpM0": {
+    "title": "Event-driven Process Chain Model (EPC)",
+    "description": "The Event Driven Process Chain (EPC) model is a flowchart-based diagramming method that supports the documentation and analysis of business processes. EPCs are frequently used in the field of UX design to aid in identifying areas for optimization and improvement.\n\nIn an EPC model, events, functions, and control flow are the primary components.\n\n*   **Event**: Represents a specific point in time, such as the start, end or a change in a process.\n*   **Function**: Represents an action or task that needs to be performed. Functions typically connect to events and other functions within a process chain.\n*   **Control Flow**: Illustrates the flow of activities in the process chain by connecting events and functions with arrows, showing the sequence of tasks.\n\nCreating an EPC model involves the following steps:\n\n*   Identify the main activities and events in the process to be modeled.\n*   Define the flow of activities by connecting events and functions using arrows.\n*   Identify decision points or branches in the process, where alternative paths may be followed.\n*   Analyze the model to identify areas for improvement, such as bottlenecks, inefficiencies or redundancies.\n\nEPC models are beneficial for UX designers as they provide a clear, visual representation of the business processes. This helps in understanding how a user's interactions with a product or service are tied to the overall process flow. Consequently, insights gained from EPC models can inform the UX design process in terms of the required steps and interactions, potential pain points, and opportunities for innovation.",
+    "links": []
+  },
+  "jy5jtSEyNE8iJpad27rPX": {
+    "title": "Business Process Model & Notation (BPMN)",
+    "description": "Business Process Model and Notation (BPMN) is a graphical representation of business processes, providing a standardized and easy-to-understand method for visualizing different aspects of a business. By using BPMN, UX designers can analyze and optimize business processes and workflows, which ultimately improves the overall user experience.\n\nKey Components of BPMN\n----------------------\n\n*   Flow Objects: Main building blocks of a BPMN diagram, which include events, activities, and gateways.\n*   Connecting Objects: Linking elements between flow objects, such as sequence flows, message flows, and associations.\n*   Swimlanes: Visual elements that help organize activities based on roles or responsibilities.\n*   Artifacts: Supplementary elements providing additional information, such as data objects, groupings, and annotations.\n\nBenefits of BPMN for UX Design\n------------------------------\n\n*   **Visualization**: BPMN offers a clear visual layout of business processes, allowing UX designers to understand the overall structure easily.\n*   **Standardization**: As an internationally recognized standard, BPMN ensures consistent interpretation and communication among team members.\n*   **Flexibility**: BPMN can accommodate various levels of complexity, enabling designers to model simple or complex processes as needed.\n*   **Collaboration**: By bridging the gap between technical and non-technical stakeholders, BPMN empowers cross-functional collaboration throughout the design process.\n\nTo incorporate BPMN in your UX design process, you'll need to familiarize yourself with its various elements and syntax. Consider leveraging BPMN tools and resources to create diagrams that accurately represent your target user's needs and the corresponding business processes. By doing so, you'll be able to craft a more precise and effective user experience.",
+    "links": []
+  },
+  "6yCBFwntQ_KxFmmGTJ8iR": {
+    "title": "Prototyping",
+    "description": "Prototyping is a crucial stage in the UX design process, where designers create a representation of the product to test its usability and functionality. This allows designers to uncover any issues, gather feedback, and iterate on the design before the actual development stage. Prototypes can range from simple sketches to fully interactive and detailed models. There are several types of prototyping, such as:\n\nLow-Fidelity Prototyping\n------------------------\n\nLow-fidelity prototypes are simple, rough representations of the design that focus on the overall structure and main functionalities. They are fast to create and allow designers to quickly test ideas and gather user feedback. Examples include:\n\n*   Paper sketches: Drawings made on paper that convey the basic layout and structure of the interface.\n*   Wireframes: Simple digital representations of the user interface, showing the placement of elements without any visual styling.\n\nHigh-Fidelity Prototyping\n-------------------------\n\nHigh-fidelity prototypes are more detailed and interactive, closely resembling the final product. They include the visual design, animations, and interactions, allowing for effective user testing and showcasing the design to clients or stakeholders. Examples include:\n\n*   Interactive mockups: Clickable representations of the interface that incorporate visual design and interactions, often created using prototyping tools such as Sketch, Adobe XD, or Figma.\n*   HTML prototypes: Interactive prototypes built using HTML, CSS, and JavaScript, which can be a good option if the designers have coding skills and want a more accurate representation of the final product.\n\nChoosing the Right Prototyping Method\n-------------------------------------\n\nThere is no one-size-fits-all approach to prototyping. The best method depends on factors such as the project's goals, the stage of the design process, available resources, and the level of detail needed. Generally, low-fidelity prototyping is best for early stages of design, when the focus is on testing the main structure and functionality, while high-fidelity prototyping is better suited for later stages when refining the visual design and interactions.\n\nBenefits of Prototyping\n-----------------------\n\nPrototyping is essential in UX design because it:\n\n*   Saves time and money: By identifying and addressing usability or design issues early in the process, you can avoid costly redesigns or development changes.\n*   Facilitates collaboration: Prototypes enable designers, stakeholders, and developers to discuss the design and give meaningful feedback.\n*   Enhances user experience: Iterative testing and refining the design based on feedback ensures the final product meets user needs and expectations.\n\nIn conclusion, prototyping is a crucial step in the UX design process that helps designers test ideas, gather feedback, and iterate on the design, ultimately leading to a more user-centered final product.",
+    "links": []
+  },
+  "90_M5qABC1vZ1nsXVyqFJ": {
+    "title": "Good Layout Rules",
+    "description": "In the world of UX design, a good layout is crucial to ensure your prototype is intuitive and user-friendly. By following these good layout rules, you can ensure your designs are efficient, attractive, and easy to navigate for users.\n\nConsistency\n-----------\n\nBeing consistent with your design is vital in creating an easy-to-navigate interface. Utilize the same color schemes, typography, and other design elements consistently throughout your prototype to make it visually cohesive and user-friendly.\n\nAlignment and Spacing\n---------------------\n\nEnsure all the elements on your prototype are aligned and spaced properly. This helps create a well-structured and clean look, while also making it easy for users to navigate and understand your design.\n\nVisual Hierarchy\n----------------\n\nEstablish clear visual hierarchy by using size, color, contrast, and white space effectively. This helps users identify important elements on the screen quickly and understand the flow of your design easily.\n\nGrouping of Elements\n--------------------\n\nGroup related elements together, such as navigation menus or form input fields. This helps users recognize the purpose and function of each section more quickly and intuitively.\n\nBalance and Proportion\n----------------------\n\nCreate a balanced and proportional look by distributing elements on the screen evenly. This can be achieved through the use of grids or other layout techniques that help maintain a sense of harmony and order in your design.\n\nAccessibility\n-------------\n\nEnsure your design is accessible to all users by considering factors such as text size, contrast, and color combinations. Aim to create an inclusive prototype that caters to people of different abilities and preferences.\n\nResponsiveness and Flexibility\n------------------------------\n\nMake sure your prototype can adapt to different screen sizes and devices, ensuring a seamless user experience across various platforms. This is particularly important when designing for web and mobile applications.\n\nIterating and Testing\n---------------------\n\nAs you develop your design, continually test and iterate on your layout based on user feedback and data. This process will help refine your design and ensure it meets the needs and expectations of your users.\n\nBy incorporating these good layout rules into your prototyping process, you'll be well on your way to creating a user-friendly and effective design that meets the goals and objectives of your project.",
+    "links": []
+  },
+  "t46s6Piyd8MoJYzdDTsjr": {
+    "title": "Figma",
+    "description": "[Figma](https://www.figma.com/) is a powerful and versatile web-based design tool that allows designers, developers, and stakeholders to collaborate on UI and UX projects in real-time. It's an excellent choice for creating wireframes and high-fidelity prototypes and supports vector editing, responsive design, and team collaboration.\n\nKey Features\n------------",
+    "links": []
+  },
+  "HI_urBhPqT0m3AeBQJIej": {
+    "title": "Adobe XD",
+    "description": "Adobe XD (Experience Design) is a powerful design and prototyping tool that allows UX designers to create wireframes, mockups, and interactive prototypes for various digital projects. It is available for both Mac and Windows, and it focuses on providing an easy-to-use, intuitive interface for designing responsive websites, mobile apps, and more.\n\nKey Features of Adobe XD\n------------------------\n\n*   **Design tools**: Adobe XD offers a set of powerful design tools, such as vector drawing, the ability to import images, and a range of pre-defined UI components to help you create aesthetically pleasing designs. The built-in grid system allows for precise alignment and consistency across your designs.\n    \n*   **Responsive artboards**: XD allows you to create multiple artboards for different devices and screen sizes. This enables you to visualize and design in one go, for multiple device types.\n    \n*   **Prototype and Interactions**: With Adobe XD, you can easily add interactions to your designs. This helps in better communication of your ideas and makes it easier for clients and developers to understand your vision. The preview mode enables you to test your prototype and see the interactions in real-time.\n    \n*   **Collaboration and Sharing**: Adobe XD simplifies collaboration between team members, stakeholders, and developers. You can create shared design specs and live URLs for your prototypes, gather feedback, and even co-edit documents with other designers in real-time.\n    \n*   **Integrations**: XD seamlessly integrates with other Adobe Creative Cloud applications, such as Photoshop, Illustrator, and After Effects, enabling smoother workflows and consistency across your designs. It also supports third-party plugins to expand its capabilities.\n    \n\nTo get started with Adobe XD, you'll need to download and install the application from the [Adobe Creative Cloud website](https://www.adobe.com/products/xd.html). Adobe offers a free basic plan for XD, which allows you to work on one shared document at a time and a limited number of shared prototypes and design specs.\n\nAs a designer, familiarizing yourself with Adobe XD's features and learning how to effectively use it can significantly improve your design process, making your wireframing and prototyping tasks quicker and more efficient.",
+    "links": []
+  },
+  "nb7Ql1gvxqEucsGnIWTyY": {
+    "title": "Sketch",
+    "description": "Sketch is a powerful digital design tool specifically tailored for user interface (UI) and user experience (UX) design. As part of the creative process, designers use Sketch to create wireframes, visual mockups, and interactive prototypes that help plan and iterate their ideas.\n\nKey Features\n------------",
+    "links": []
+  },
+  "fZkARg6kPXPemYW1vDMTe": {
+    "title": "Balsamiq",
+    "description": "Balsamiq is a popular wireframing tool that helps designers, developers, and product managers to quickly create and visualize user interfaces, web pages, or app screens. It's an easy-to-use software that allows you to focus on ideas and concepts rather than getting caught up in pixel-perfect designs.\n\n**Key Features of Balsamiq**",
+    "links": []
+  },
+  "U4ZEFUcghr9XjSyf-0Np7": {
+    "title": "Call to Action",
+    "description": "A **Call to Action (CTA)** is a UX pattern that encourages users to take a specific action on a website, app, or other digital product. It is an essential component of effective UX design, as it helps guide users through the experience and accomplish their goals. CTAs can come in various forms, including buttons, links, images, or text.\n\nImportance of Call to Action\n----------------------------\n\n*   **Increased conversion rates**: A well-placed and well-designed CTA can significantly increase conversion rates, leading to more sign-ups, purchases, or other desired user actions.\n*   **Guides user behavior**: CTAs help to guide users through the flow of your product, and can assist in providing a clear and concise user journey.\n*   **Highlighting key features**: A strong CTA can bring attention to key features or important information that you want your users to notice and engage with.\n\nDesigning an Effective Call to Action\n-------------------------------------\n\nTo create an effective CTA, consider the following factors:\n\n*   **Placement**: The placement of a CTA is crucial to its effectiveness. It should be easily noticeable and accessible without overwhelming or distracting users. In most cases, placing CTAs above the fold (the portion of the website visible without scrolling) has proven to be effective.\n*   **Size and shape**: The size and shape of a CTA should be consistent with the overall design of your product. Make sure it is large enough to be easily noticed, but not too large that it overwhelms other content.\n*   **Color and contrast**: Choose a color for your CTA that stands out from the rest of your design. High contrast between the CTA button and its surrounding elements can make it more noticeable and draw attention.\n*   **Clear and concise copy**: The text on your CTA should be clear, concise, and tell users exactly what to expect when they click on it. Use action-oriented language like \"Sign Up,\" \"Learn More,\" or \"Start Now\" to encourage users to take action.\n\nCTA Best Practices\n------------------\n\nHere are some best practices to follow when designing and implementing CTAs:\n\n*   Limit the number of CTAs on a single page or screen to maintain focus and avoid confusion.\n*   Ensure the CTA is relevant to the content and user experience.\n*   Test different CTA variations, placements, and designs to determine which is most effective for your target audience.\n\nBy incorporating CTAs into your UX design, you can create a more engaging, user-friendly experience that helps guide users through your product and ultimately drives them to take the desired actions.",
+    "links": []
+  },
+  "G4Ap91NgZfkV-54EuWe-Z": {
+    "title": "Status Reports",
+    "description": "Status reports are an essential component of UX patterns that aid in keeping users informed about the current state of the system, task progress, and any relevant updates. By providing real-time feedback, users can understand the outcome of their actions which ultimately helps in building trust, reducing confusion, and enhancing overall user satisfaction.\n\nHere are some key aspects to consider when designing status reports for your application:\n\nTiming\n------\n\nChoose the appropriate time to display status reports so that it doesn't interrupt the user's ongoing activities. For instance, progress bars should be visible only when a task requires some time to complete, while error messages should appear right after an incorrect input.\n\nPlacement\n---------\n\nPosition the status reports in a way that they naturally draw users' attention without distracting them from their primary tasks. Some commonly used placements include the top or center of the page for critical alerts, and near the input fields for validation feedback.\n\nContent\n-------\n\nKeep the content of your status report simple, concise, and informative. It should be easy for the user to understand what's happening and, if necessary, provide clear instructions on how to proceed. Avoid jargon and use plain language that users can easily comprehend.\n\nVisual Hierarchy\n----------------\n\nDesign your status reports using visual hierarchy principles to prioritize the most important information. Make use of contrast, typography, and other visual elements to help users quickly understand the message and its level of importance.\n\nAccessibility\n-------------\n\nEnsure your status reports are accessible by providing descriptive text, like alternative text for images, or using ARIA roles for screen readers. This ensures that users with disabilities can also benefit from these useful reports.\n\nDismissal\n---------\n\nOffer users the option to dismiss non-critical status reports as per their preference. This can be done by providing a close button for banners, tooltips, and pop-ups.\n\nIn conclusion, status reports are a valuable aspect of UX design that effectively communicate essential information to users, thus improving their overall experience with your product. Integrating these principles into your UX pattern can considerably enhance your design's effectiveness and user satisfaction.",
+    "links": []
+  },
+  "mzWd-xSr7sO2RgfPbKy4T": {
+    "title": "How-to-Tips",
+    "description": "This design pattern design to provide users with guidance or tips on how to use a product or service. This pattern can be implemented in various ways, such as through tooltips, pop-ups, modals, or other interactive elements that appear on the screen.\n\nThe purpose of the \"How-to-tips\" UX pattern is to help users learn how to use a product or service quickly and easily, without having to refer to external documentation or search for answers online. By providing guidance and tips directly within the user interface, this pattern can improve the user experience and reduce frustration, especially for new or inexperienced users.\n\nExamples of this pattern include:\n\n*   Tooltips that appear when users hover over or click on certain elements, providing information about the function or purpose of that element.\n*   Pop-ups or modals that appear when users first interact with a product or service, providing an overview or tutorial on how to get started.\n*   Interactive tutorials or walkthroughs that guide users through key features or functions of a product or service, step-by-step.\n\nOverall, the \"How-to-tips\" UX pattern is a valuable tool for improving the usability and accessibility of a product or service, helping users to learn how to use it effectively and efficiently.",
+    "links": []
+  },
+  "wFWidrOZ5EHPgo9uuUclK": {
+    "title": "Reminders & Planning Prompts",
+    "description": "In the realm of UX design, **reminders and planning prompts** are essential components that ensure users remember to complete specific actions or tasks at the right time. By including these prompts within the user flow, you can aid users in staying on track and reduce the likelihood of missed deadlines or incomplete tasks.\n\nWhy Use Reminders and Planning Prompts?\n---------------------------------------\n\nUsers often have multiple tasks to juggle simultaneously, making it easy for things to slip through the cracks. By incorporating reminders and planning prompts into your application, you can help combat:\n\n*   **Forgetfulness**: People sometimes need a gentle nudge to remember their next step or obligation.\n*   **Procrastination**: Timely reminders can encourage users to prioritize their tasks and meet deadlines.\n*   **Lack of motivation**: Well-crafted planning prompts can inspire users to take action and stay engaged with your product.\n\nTypes of Reminders and Planning Prompts\n---------------------------------------\n\nTo provide effective, well-timed reminders and prompts, consider employing the following methods:\n\n*   **Push notifications**: Utilize mobile or desktop notifications to remind users about upcoming tasks, appointments, or deadlines.\n*   **In-product prompts**: Place on-screen prompts to encourage users to take specific actions while using the application.\n*   **Email reminders**: Send scheduled emails to users as reminders for tasks or appointment confirmation.\n*   **Badges**: Use badges or other visual cues to indicate pending tasks, such as unread messages or incomplete items in a to-do list.\n*   **Calendar integration**: Integrate your application with calendar tools, so users can easily add and access reminders and events.\n\nStrategies for Effective Reminders and Planning Prompts\n-------------------------------------------------------\n\nTo ensure that your reminders and planning prompts encourage users to take action, follow these guidelines:\n\n*   **Customization**: Allow users to customize their reminders, such as setting preferred notification times or choosing the method of delivery.\n*   **Context**: Provide context around the reminder so users have enough information upfront to determine the task's priority.\n*   **Actionable**: Make your reminders engaging and actionable, so users can directly take action from the reminder or prompt.\n*   **Timeliness**: Consider the user's time zone and availability when scheduling reminders and plan accordingly.\n\nIncorporating reminders and planning prompts into your UX design strategy can improve user engagement, satisfaction, and product success. By considering the different types and strategies outlined above, you can create a user experience that keeps your audience actively engaged with your application.",
+    "links": []
+  },
+  "9vA3ZWMiKG6NiEqGDvcFR": {
+    "title": "Decision-Making Support",
+    "description": "Decision making support plays a crucial role in UX design by providing users with the necessary information, options, and feedback to make informed choices when interacting with a product or interface. This UX pattern focuses on helping users make decisions through clear presentation of information, minimizing cognitive load, and offering guidance throughout the various interactions.\n\nKey Elements of Decision Making Support\n---------------------------------------\n\n*   **Clear presentation of information**: Present complex information in a simple, easily digestible format. Break down large amounts of data into smaller chunks, use visuals (e.g., icons, images, graphs) to convey information, and provide clear labeling and headings.\n    \n*   **Minimize cognitive load**: Reducing the mental effort required by users when making decisions can lead to better decision-making and higher satisfaction. Limit the number of options presented, group similar items together, and use progressive disclosure to provide additional details when necessary.\n    \n*   **Feedback and guidance**: Providing feedback and guidance can help users understand the implications of their decisions and options. Use micro-interactions (e.g., hover effects, tooltips) to clarify the meaning of interactive elements and provide suggestions or recommendations.\n    \n*   **Defaults and pre-selected options**: Set sensible defaults and pre-selected options to help users make decisions quickly, while also allowing flexibility for customization. This can prevent decision paralysis and reduce frustration for users with limited knowledge or expertise.\n    \n*   **Comparison tools**: Offer easy-to-use comparison tools for users to weigh different options, especially in cases where the decision involves multiple factors. This can be provided through side-by-side comparison tables, or visual aids that highlight differences between options.\n    \n\nTips for Implementing Decision Making Support\n---------------------------------------------\n\n*   Empathize with your users and create user personas to understand their needs, goals, and preferences when making decisions.\n*   Conduct usability tests to evaluate the effectiveness of your decision-making support features and iterate based on user feedback.\n*   Take into account different use cases and decision-making styles across your target audience, and design support features that cater to these variations.\n*   Be cautious not to overwhelm users with too much decision support, which can lead to increased cognitive load and poor user experience.\n\nBy incorporating effective decision-making support into your UX design, you can enhance user experience, increase satisfaction, and ultimately, help your users make better choices while interacting with your product.",
+    "links": []
+  },
+  "JSBiw0C6aq1LhA33y79PM": {
+    "title": "Behavior Change Games",
+    "description": "Behavior change games are a powerful UX design pattern that help users adopt new habits or make positive lifestyle changes. These games are typically designed to be engaging, enjoyable, and motivating, utilizing various game elements and mechanics to encourage users to take desired actions.\n\nKey elements of behavior change games\n-------------------------------------\n\n*   **Set clear objectives**: Define specific goals users should achieve, such as losing weight or learning a new skill. Well-defined objectives provide a strong focus for the game and encourage user engagement.\n    \n*   **Feedback and progress**: Provide real-time feedback and track user progress to create a sense of accomplishment. This can include visual cues, points, badges, or leveling up systems.\n    \n*   **Social interaction**: Utilize social features, such as sharing achievements, comparing results with friends, or team challenges. This enables users to work together, fosters a sense of community, and enhances motivation through friendly competition.\n    \n*   **Reward system**: Implement a reward system that grants virtual or real rewards for completing tasks or reaching milestones. These rewards can be intrinsic (e.g., personal satisfaction) or extrinsic (e.g., discounts or prizes).\n    \n*   **Gamification**: Incorporate game-like elements, such as storytelling, quests, or time-limited challenges. These elements add an entertaining aspect, improve user experience, and make the behavior change process more enjoyable.\n    \n\nBenefits of behavior change games\n---------------------------------\n\n*   **Increased motivation**: By turning the behavior change process into a game, users are often more motivated to participate and stay engaged.\n    \n*   **Higher user retention**: Engaging games can increase user retention, resulting in higher long-term success rates for behavior change.\n    \n*   **Measurable results**: These games allow users to easily track progress and outcomes, helping them understand the impact of their actions and reinforcing positive behavior.\n    \n*   **Personalization**: Games can be tailored to individual users' preferences and play styles, making the experience more enjoyable and relevant.\n    \n*   **Support network**: The inclusion of social features creates a community of support, forging connections between individuals with similar goals and fostering accountability.\n    \n\nWhen designing behavior change games, it's essential to keep user experience in mind, and create an enjoyable and motivating experience. Balancing fun and educational elements can result in a powerful tool for guiding users towards positive change in their lives.",
+    "links": []
+  },
+  "fbIur1tEIdNDE6gls4Bru": {
+    "title": "Gamification",
+    "description": "Gamification is a UX design pattern that involves incorporating elements of game design into non-game applications or websites to enhance user engagement and create enjoyable experiences. By using game mechanics like points, achievements, competition, and progress-tracking, designers can make mundane tasks more appealing and motivate users to interact with the content or perform certain actions.\n\nBenefits of Gamification\n------------------------\n\n*   **Increased engagement**: Gamification helps in capturing the user's attention and encourages them to spend more time interacting with the product.\n*   **Motivation**: Game mechanics like points, badges, and leaderboards act as incentives, motivating users to perform a desired behavior or accomplish specific goals.\n*   **Improved learning**: Gamification can make learning new concepts or skills more enjoyable, allowing users to better retain information.\n*   **User retention**: By creating a sense of achievement and fostering friendly competition, gamification can inspire users to keep returning to the product.\n\nKey Elements of Gamification\n----------------------------\n\n*   **Points**: Points are a quantifiable way to track the user's accomplishments and give immediate feedback. They can be used as a currency to unlock specific content or features.\n*   **Badges**: Badges are visual representations of achievements that users can earn by completing certain activities or reaching milestones, which creates a sense of accomplishment.\n*   **Leaderboards**: Leaderboards display users' progress in comparison to others, encouraging competition and fostering motivation to improve one's standing within the community.\n*   **Progress tracking**: Providing a progress bar or checklist helps users visualize their journey and gives them a clear idea of what they have achieved and what's remaining.\n\nImplementing Gamification\n-------------------------\n\nWhen implementing gamification in your UX design, consider the following factors:\n\n*   **Target audience**: Define your target audience and analyze their demographics, preferences, and pain points to provide a suitable gamification experience.\n*   **Purpose**: Identify the desired outcome the gamification process aims to achieve, such as increased engagement, user acquisition, or learning.\n*   **Relevance**: Ensure that the gamification elements align with your product's purpose and add value to the user experience, rather than feeling forced or gimmicky.\n*   **Balancing challenge and reward**: Create a balance between the level of challenge and the offered rewards to maintain user interest.\n*   **Feedback**: Provide users with timely feedback on their progress and performance to keep them engaged and informed.\n\nBy incorporating gamification into your UX design, you can create more engaging and captivating experiences that keep users coming back for more. Just remember to ensure that the game elements are relevant to the product's purpose and contribute positively to the overall user experience.",
+    "links": []
+  },
+  "eYZf67rnhOksfh44hnzHg": {
+    "title": "Planners",
+    "description": "Planners are an essential aspect of UX design, helping users accomplish complex tasks by breaking them down into manageable steps. Planners are particularly useful in situations where users are expected to make decisions or deal with a range of options. They help to create an engaging and interactive experience, guiding users to achieve their goals efficiently.\n\nCharacteristics of Planners\n---------------------------\n\nThere are a few key characteristics that define planners in UX design:\n\n*   **Clear Guidance:** Planners provide clear instructions and guidance on the various steps involved, making it easier for users to navigate through the process.\n    \n*   **Progress Indicators:** Planners typically use some form of progress indicator, such as a progress bar or a checklist, to show users how far along in the process they are.\n    \n*   **Error Prevention & Handling:** Planners strive to prevent user errors by providing input validation, feedback, and clear guidelines on what needs to be done. They also handle errors effectively, allowing users to recover and move forward, without getting frustrated.\n    \n*   **Flexibility:** Planners offer users the flexibility to complete tasks at their own pace, and provide options for changing or updating information at any stage in the process.\n    \n*   **Consistency:** Planners maintain consistency in the design and presentation of information, ensuring that the user experience is familiar and predictable at all times.\n    \n\nTypes of Planners\n-----------------\n\nThere are various types of planners used in UX design, depending on the specific needs of the project:\n\n*   **Decision Trees:** These provide users with a sequence of binary options, guiding them through a series of choices until they reach a specific end result.\n    \n*   **Wizards:** These are step-by-step guides that walk users through a process, presenting one question or task at a time, and only moving on once the user has completed the previous step.\n    \n*   **Task Checklists:** These provide users with a list of sub-tasks or actions they must complete in order to achieve a larger goal. Users can check-off tasks as they complete them, and see their progress towards the goal.\n    \n*   **Interactive Conversations:** These mimic a conversational interaction between the user and the system, using natural language processing to guide users through tasks or decision-making processes.\n    \n\nImplementing Planners\n---------------------\n\nWhen incorporating planners into your UX design, consider the following best practices:\n\n*   Identify the core tasks or decisions your user needs to make and create a logical flow for each process.\n    \n*   Use clear and concise language to guide users through steps, ensuring instructions are easy to follow and understand.\n    \n*   Implement appropriate progress indicators or feedback mechanisms to show users how close they are to completing the task.\n    \n*   Focus on error prevention and offer easy ways for users to recover from mistakes.\n    \n*   Ensure that your planner design is consistent with the overall user interface and user experience goals, while also being flexible to accommodate user preferences and habits.\n    \n\nBy following these best practices and tailoring planners to meet the needs of your users, you can create a more engaging and user-friendly experience that allows users to complete complex tasks with ease.",
+    "links": []
+  },
+  "esWGzYUJwv7_xGjq6kpVE": {
+    "title": "Reminders",
+    "description": "**_Reminders_** play an essential role in the user's experience, especially when it comes to retaining user attention and engagement. They can be helpful in making sure that the user stays focused on their tasks, remembers essential information or deadlines, and continually interacts with your product or design.\n\nImportance of Reminders\n-----------------------\n\n*   **User Engagement**: Reminders can act as an opportunity to drive users back to your app or website, ensuring they don't forget to use your product or service.\n*   **Timely Notifications**: When a reminder is well-timed and relevant, it can be a useful tool to prevent users from missing out on crucial information or essential tasks.\n*   **Positive User Experience**: Effective use of reminders can create a positive experience for users, making them feel supported and confident in using your product or service.\n\nTypes of Reminders\n------------------\n\nThere are several types of reminders that can be used in UX design. Here are some common ones:\n\n*   **Time-based Reminders**: Set at specific intervals or times, these reminders are designed to ensure users don't forget important tasks or events related to your product or service.\n*   **Location-based Reminders**: Triggered by entering or leaving certain locations, these reminders can be useful for tasks related to a specific place or area.\n*   **Action-based Reminders**: Initiated by user actions, these reminders can provide useful prompts or follow-up actions based on user behaviors within your app or website.\n\nBest Practices\n--------------\n\nHere are a few best practices to consider when incorporating reminders into your UX design:\n\n*   **Be Timely and Relevant**: Ensure that reminders are helpful to the user by making them timely and relevant to the user's needs.\n*   **Keep it Simple**: Use clear, concise language that is easy for users to understand and act upon.\n*   **Avoid Overloading Users**: Too many reminders can become overwhelming and irritating, negatively impacting the user experience. Strike a balance between providing important reminders and respecting the user's time and attention.\n*   **Allow Personalization**: Where possible, provide the user with options to customize the timing and frequency of reminders, enabling them to personalize their experience to suit their preferences.\n*   **Consider Design Elements**: Reminders can be delivered through several methods, including in-app notifications, push notifications, and emails. Consider the most appropriate method for your user base and ensure the design of the reminder is visually appealing and easy to engage with.\n\nIn conclusion, thoughtfully implemented reminders can significantly enhance the user experience and improve user engagement, retention, and satisfaction. By following best practices and considering the user's needs, you can create effective reminders that users appreciate and value.",
+    "links": []
+  },
+  "FoKtBRuTuMD2SZDHLWS-5": {
+    "title": "Social Sharing",
+    "description": "In the realm of UX design, **Social Sharing** is a crucial pattern that allows users to share content from a website or app to various social media platforms. It helps in creating interaction between users and the content, engaging the audience and generating more traffic to the source.\n\nBenefits of Social Sharing\n--------------------------\n\n*   Increase in brand visibility and awareness\n*   Drive more traffic to the website or app\n*   Higher chances of content going viral\n*   Encourages engagement and conversation around your content\n*   Improves organic search rankings\n\nDesigning Effective Social Sharing Buttons\n------------------------------------------\n\n*   **Positioning**: Place the social sharing buttons at an easily accessible location on the page, e.g., top, bottom, or alongside the content.\n*   **Size and Style**: Opt for clear and recognizable social icons that are easy to tap or click. Ensure their size is adequate to avoid any UX issues.\n*   **Customization**: Tailor the design of social sharing buttons to complement your website or app's visual appeal.\n*   **Selective platforms**: Focus on the most popular or relevant social media platforms for your target audience; not every platform may be necessary.\n*   **Share counts**: Show the number of shares for individual content pieces when appropriate, as it adds social proof and encourages more shares.\n*   **Mobile optimization**: Ensure your social sharing buttons are functional and visually appealing on mobile devices, as a significant portion of sharing occurs via mobile.\n\nIncorporating social sharing into your UX design not only provides opportunities for increased engagement but also serves as an effective marketing tool. Remember, a well-designed and strategically placed social sharing component can lead to a higher reach and greater success for your brand.",
+    "links": []
+  },
+  "g-bcan_JnjJfg0_fMOb64": {
+    "title": "Goal Trackers",
+    "description": "Goal trackers are essential UX patterns that enable users to monitor their progress towards accomplishing a specific task or objective. Essentially, they help users stay motivated, organized and informed about their journey within an app, website, or system. In this guide, we'll explore the significance of goal trackers, and how to effectively design and incorporate them in your projects.\n\nWhy use goal trackers?\n----------------------\n\n*   **Motivation**: By visibly displaying the progress made, goal trackers constantly motivate users to actively participate in the experience and work towards completing their goals.\n*   **Expectation Management**: They provide clear guidance on the steps required, inform users about the remaining tasks or subgoals, and aid users in estimating the time and effort needed.\n*   **Sense of Achievement**: Goal trackers can enhance user satisfaction by celebrating milestones and achieved objectives, reaffirming that the effort invested has produced tangible results.\n*   **Personalization**: Users can customize their experience by setting up personalized goals and tracking their progress, fostering a greater sense of ownership and connection.\n\nEssential components of goal trackers\n-------------------------------------\n\nA well-designed goal tracker will typically include the following elements:\n\n*   **Visual Progress Bar**: This represents the user's progress towards completing the overall goal. It is usually color-coded, with a percentage or numerical value indicating the extent of the progress made.\n*   **Step Indicators**: These are specific milestones or subgoals that users need to complete in order to achieve the main goal. They help break down the overall process into manageable, smaller tasks.\n*   **Animations & Feedback**: Using animations, notifications, and other visual cues can make users feel rewarded for their progress, reinforcing positive behavior.\n*   **Summaries & Overviews**: A concise summary or overview of the user's progress and remaining tasks/subgoals allows users to quickly ascertain their position within the overall structure.\n\nDesigning effective goal trackers\n---------------------------------\n\nWhen designing a goal tracker, consider these best practices for optimal UX:\n\n*   **Simplicity**: Keep the design and presentation of the goal tracker simple and clear, avoiding unnecessary complexity or clutter.\n*   **Relevance**: Ensure that the tracked goals are closely aligned with the user's objectives, and make the process of updating or setting these goals as seamless as possible.\n*   **Adaptable**: Make the goal tracker adaptable and flexible, allowing users to change or modify their goals as needed.\n*   **Accessibility**: Design the goal tracker to be easily accessible, allowing users to monitor their progress without disrupting their workflow or navigation.\n\nIn conclusion, goal trackers play an important role in UX design to drive user engagement, satisfaction, and overall success. By understanding their purpose and components, and incorporating thoughtful design principles, you can create goal trackers that enhance your users' experience and promote the accomplishment of their desired objectives.",
+    "links": []
+  },
+  "f0n2JKxpcuP0JW-h4CvwN": {
+    "title": "Tutorials",
+    "description": "Tutorials are an important aspect of UX Design, as they help users understand and learn how to navigate through a new application, software or website. It is essential to create engaging, informative and easy-to-follow tutorials to ensure users can quickly comprehend the interface and become efficient in navigating it.\n\nIn this section, we will discuss the importance of tutorials in UX Design and provide best practices for creating effective tutorials.\n\nImportance of Tutorials\n-----------------------\n\n*   **Guidance for new users:** Tutorials provide an opportunity for users to learn how to use a new software or application proficiently. They are particularly helpful for first-time users, who are often intimidated by the learning curve.\n*   **Boost user confidence:** Well-executed tutorials help users gain confidence in their ability to navigate a software, ultimately leading to increased user satisfaction and long-term engagement.\n*   **Minimize confusion:** Tutorials can help users avoid confusion and frustration by offering clear instructions and demonstrations, which ultimately reduces the need for user support.\n\nBest Practices for Creating Tutorials\n-------------------------------------\n\n*   **Keep it simple and clear:** Use easy-to-understand language, avoid jargon, and break down complex concepts into smaller, manageable steps.\n*   **Use visuals:** Incorporate diagrams, screenshots, and videos if possible. Visuals can enhance learning and make it easier for users to understand complex instructions.\n*   **Make it interactive:** Encourage user engagement by making the tutorial interactive. This can be achieved by incorporating quizzes, allowing users to practice new skills, and providing immediate feedback.\n*   **Be concise:** Long tutorials can be overwhelming and discourage users. Present only the necessary information, and keep the tutorial as short and to-the-point as possible.\n*   **Test and iterate:** Regularly test your tutorials to ensure they are still relevant and effective. Gather user feedback to identify areas for improvement, and make updates accordingly.\n\nRemember, a well-designed tutorial can greatly enhance a user's experience with your software or application. Invest time and effort into creating engaging, informative and easy-to-follow tutorials, and enjoy the benefits of a more skilled and satisfied user base.",
+    "links": []
+  },
+  "VUf72i5hYaLR_8ul9EzmM": {
+    "title": "UX Best Practices",
+    "description": "UX design, or user experience design, is essential for creating user-friendly and effective products. In this section, we'll discuss some of the best practices that can help you create an optimal user experience for your products.\n\nUnderstand your users\n---------------------\n\nBefore you start designing any product or feature, it's crucial to **know and understand your users**. Conduct user research, create user personas, and use these insights to tailor your design to the needs and preferences of your target audience.\n\nFocus on usability\n------------------\n\nOne of the main goals of UX design is to create products that are **easy to use and navigate**. Aim for simplicity, consistency, and clarity in your design, and make sure to test your product with real users to identify potential usability issues.\n\nDesign for accessibility\n------------------------\n\nDesigning for **accessibility ensures that your product can be used by people with disabilities**, such as visual or motor impairments. This involves providing alternative input methods, like keyboard navigation, as well as preparing your site for assistive technologies such as screen readers.\n\nUtilize responsive design\n-------------------------\n\nToday's users access digital products from various types of devices, and it's important to ensure that your product offers a consistent, enjoyable experience on all screens. Utilize **responsive design techniques** to accommodate different device sizes and capabilities.\n\nOpt for clear and concise content\n---------------------------------\n\nWell-written, easy-to-understand content is a crucial part of UX design. Use **simple language, clear headings, and bullet points** to help users quickly find and digest the information they need.\n\nEnable user control and feedback\n--------------------------------\n\nAllow users to **control their experience** by making it easy for them to undo actions, navigate through your product, and provide feedback. Providing visual feedback, like error messages or confirmation messages, can help users feel more confident using your product.\n\nOptimize page load times\n------------------------\n\nSlow-loading pages can negatively affect user experience and lead to users leaving your product. To ensure a positive experience, **optimize the performance of your website or application** by compressing images, minimizing the use of scripts, and employing caching techniques.\n\nBe consistent in design and layout\n----------------------------------\n\nConsistency in design elements, such as typography, colors, and layout, creates a cohesive user experience and helps to build familiarity and trust with users. Create and follow a **design system or style guide** to maintain consistency across your product.\n\nTest and iterate\n----------------\n\nUsability testing and iterative design are essential components of the UX design process. **Conduct usability tests** with real users to identify pain points and areas of improvement, and continually iterate and improve your design based on feedback and insights gained.\n\nBy applying these UX best practices, you'll be well on your way to creating user-friendly, effective products that lead to greater user satisfaction and success.",
+    "links": []
+  },
+  "IjqH_Ev2fDWG0QDQ9c9eN": {
+    "title": "Clear the Page of Distractions",
+    "description": "To create an effective UX design, it is essential to focus on the user's attention and reduce any distractions that might be present on the webpage. This will not only improve the usability of your website, but it will also make it more visually appealing and engaging. Here are some tips for eliminating distractions from your design:\n\nKeep it Simple\n--------------\n\nIt's crucial to ensure your design is clean and straightforward. Stick to essential design elements, and avoid using excessive images, icons, or other visual elements that may distract users from the main content.\n\nUse White Space\n---------------\n\nIncorporate white space, also known as negative space, throughout your design. The appropriate use of white space provides relief for users and makes it easier to process the information on the page.\n\nEstablish a Visual Hierarchy\n----------------------------\n\nOrganizing content according to its importance will help users focus on the most crucial information. Creating a clear visual hierarchy can be achieved by using font sizes, colors, and positioning to guide the user's attention.\n\nUse Consistent Navigation\n-------------------------\n\nKeep your website's navigation consistent throughout the site to reduce potential confusion. This allows users to quickly find what they are looking for without getting lost or overwhelmed.\n\nMinimize Popups and Ads\n-----------------------\n\nExcessive use of popups or ads can be distracting and annoying to users. Keep their usage to a minimum, and ensure they are not disruptive to the overall user experience.\n\nOptimize Load Times\n-------------------\n\nEnsure that your webpage loads quickly, as slow loading times can lead to user frustration and abandonment. Optimize images and other media, and consider lazy loading techniques for a smoother experience.\n\nBy following these guidelines and effectively clearing your page of distractions, you can create a user-friendly and aesthetically pleasant design that will keep your users engaged and focused on the most important elements of your website.",
+    "links": []
+  },
+  "hDj3HaYAM7K1UJmP_T52n": {
+    "title": "Make it Clear, Where to Act",
+    "description": "When designing a user interface, it is essential to guide your users in such a way that they can effortlessly understand where they need to act. This means making it abundantly clear where the actionable elements are on the screen.\n\nHere are a few strategies to ensure users can easily identify where to act:\n\n*   **Use Affordances:** Make use of [affordances](https://www.interaction-design.org/literature/topics/affordances) to give users clues about the functionality of individual elements. For instance, buttons should look clickable, links should be visually distinguishable from plain text, and input fields should resemble an area where text can be entered.\n    \n*   **Visual Hierarchy:** Establish a [visual hierarchy](https://www.interaction-design.org/literature/topics/visual-hierarchy) within the interface by placing important actions more prominently, making them larger or more noticeable. This can be achieved through the use of size, color, contrast, and proximity.\n    \n*   **Consistent Element Patterns:** Use consistent element patterns throughout your design, ensuring that all actionable elements have the same visual styling. This helps users recognize which elements they can interact with and which ones they can't.\n    \n*   **Clear Labels and Instructions:** Provide clear labels and instructions to help users understand what different elements do, and what is expected of them. This could be explicit instructions or simply using descriptive, concise labels that are easy-to-understand.\n    \n*   **Whitespace:** Make good use of [whitespace](https://www.interaction-design.org/literature/topics/white-space) to provide breathing room between elements and group related content. This allows users to quickly grasp the structure of the page and find the points of interaction.\n    \n*   **Feedback:** Provide feedback to users when they interact with various elements. This can include hover effects, button presses, and animations that serve as confirmations of successful actions.\n    \n\nBy making it clear where users need to act, your interface becomes more accessible, efficient, and enjoyable for them to use. This will ultimately result in a more successful and engaging user experience.",
+    "links": []
+  },
+  "FXJpJDIp-JBc0-0z4PIRo": {
+    "title": "Tell User what the Action is and ask for it",
+    "description": "In the world of UX design, one of the key objectives is to maintain effective communication with users and ensure that their needs and expectations are being met. One powerful technique to achieve this is through **Tell User and Ask** strategy.\n\nTell User\n---------\n\nThis approach requires the designer to provide clear, concise, and relevant information to the user throughout their interaction with the product. This can be achieved through various means:\n\n*   **Visual cues**: Utilize colors, icons, and typography effectively to signal the user about important elements on the page or screen.\n*   **Microcopy**: Provide short, helpful pieces of text, such as labels or tooltips, to guide the user in taking appropriate actions.\n*   **Notifications**: Offer live updates, system status, and contextual feedback to keep the user informed about any ongoing processes or significant events.\n\nAsk User\n--------\n\nAnother important aspect of creating an engaging and interactive experience is through soliciting user input or feedback. This can facilitate two-way communication and ultimately contribute to a more personalized and efficient user experience. Some ways to incorporate this strategy into your design:\n\n*   **Forms and surveys**: Collect information from users in a structured and organized manner, using various input fields such as text, multiple-choice, and dropdowns.\n*   **Interactive elements**: Encourage users to engage with the interface, such as sliding for content, using progressive disclosure techniques, or utilizing drag-and-drop functionality.\n*   **Feedback mechanisms**: Provide quick and easy ways for users to express their opinions or report issues, such as clickable star ratings, feedback forms, or live chat features.\n\nBy combining the \"Tell User\" and \"Ask User\" strategies, UX designers can create a more dynamic and engaging user experience, while also staying in tune with the evolving needs and expectations of their audience.",
+    "links": []
+  },
+  "ahhffBkmd-feroleBrhJm": {
+    "title": "Make UI Professional and Beautiful",
+    "description": "Creating a professional and beautiful user interface (UI) is essential for a positive intuitive reaction. This not only captures the users' attention but also keeps them engaged with your product. A visually appealing UI establishes trust and confidence, ultimately enhancing the overall user experience (UX). In this section, we will discuss key aspects to keep in mind for designing a professional and beautiful UI.\n\nColor Scheme\n------------\n\nChoose a color scheme that complements your brand and the message you want to convey. Use colors that evoke emotions and are aesthetically pleasing. Aim for a balanced mix of primary, secondary, and accent colors. You can use online color palette generators or other resources to create a harmonious color scheme.\n\nTypography\n----------\n\nTypography plays a critical role in making your UI more readable and user-friendly. Spend time selecting a typeface that aligns well with your brand personality. Make sure that the font sizes, line heights, and letter spacing are optimized for readability. Maintain consistency in typefaces and styles throughout your design.\n\nLayout and Grid System\n----------------------\n\nOrganize the interface elements in a clear, consistent, and logical manner using a grid system. It helps you achieve a clean and professional look. A well-defined layout not only enhances the visual appeal but also improves the usability of the interface.\n\nIconography and Imagery\n-----------------------\n\nUse high-quality icons and images that are consistent in style and theme. Icons should be easily recognizable and convey the purpose of their associated actions. Opt for vector graphics and SVG files as they scale better for different screen sizes and resolutions.\n\nConsistency and Patterns\n------------------------\n\nMaintain consistency in your UI elements and their interactions. Established design patterns help users feel comfortable and familiar with your interface. Standardize navigation, buttons, and other interface components to create an intuitive and seamless experience.\n\nResponsive Design\n-----------------\n\nEnsure your design adapts well to various screen sizes and resolutions. Cater to different devices and platforms to maximize accessibility and user satisfaction. Utilize responsive design techniques, such as fluid grids, flexible images, and media queries.\n\nWhite Space\n-----------\n\nMake effective use of white space (also known as negative space) to create visual hierarchy, separate different elements, and guide the users' attention. White space is essential for a clean, balanced, and professional appearance.\n\nFeedback and Micro-interactions\n-------------------------------\n\nProvide visual feedback and subtle animations to enhance user interaction. Micro-interactions, such as hover effects, progress indicators, and animations, showcase attentiveness to detail and contribute to an engaging UX.\n\nBy incorporating these aspects, you can craft a professional and beautiful UI that promotes a positive intuitive reaction. Remember that a visually appealing interface, combined with smooth and efficient functionality, leads to a better UX, ultimately benefiting both the users and your business.",
+    "links": []
+  },
+  "C1NwA0Pivoo73GANoOaPi": {
+    "title": "Deploy Social Proof",
+    "description": "Deploying social proof is a powerful UX design principle that helps to encourage a positive intuitive reaction among users. Social proof is the concept that people tend to conform to the actions, beliefs, and attitudes of those around them, especially when they are unsure of the correct behavior in a given situation. In UX design, this means leveraging user-generated content and testimonials that demonstrate how your product or service is positively impacting others. This helps to instill trust and credibility in your design, and it can ultimately influence user engagement and decision-making.\n\nKey Aspects of Deploying Social Proof\n-------------------------------------\n\n*   **User Testimonials and Reviews**: Sharing direct quotes and reviews from satisfied users can help build trust in your product, and create a perceived sense of popularity. Make sure to include testimonials on your website or app that highlight the most compelling benefits of your product.\n    \n*   **Social Media Mentions**: Showcasing positive word-of-mouth spread organically by real users can help persuade potential customers to try your product. Incorporate social media mentions, shares, or ratings on your website or app as a way of demonstrating your product's reputation.\n    \n*   **Expert Opinions and Endorsements**: If your product is endorsed by industry experts, leaders, or influencers, this can add authority to your brand. Include these supporters' names or quotes in your UX design to show that knowledgeable individuals trust and are using your product or service.\n    \n*   **Usage Statistics**: Displaying the total number of users, downloads, or customer success stories can provide a strong indicator of the popularity of your product or service. Ensure that these statistics are accurate and up-to-date in order to maintain credibility with your audience.\n    \n*   **Trust Seals and Certifications**: Including trust seals from established organizations or certifications from industry leaders can further enhance your product's credibility. Ensure that these are relevant to your target audience and displayed prominently within your UX design.\n    \n\nBy deploying social proof strategically within your UX design, you can create a positive intuitive reaction that encourages users to trust your product, comply with your suggestions, and ultimately, choose your product over the competition.",
+    "links": []
+  },
+  "C5dKHIIgBzxtBpFgDs-hB": {
+    "title": "Deploy Strong Authority on Subject",
+    "description": "Deploying strong subject authority refers to providing the user with a sense of trust and confidence when they interact with your product. This can be achieved by showcasing your expertise and establishing your position as a reliable source of information, products or services. Let us explore the key aspects of deploying strong subject authority in UX design:\n\nReliable Content:\n-----------------\n\n*   **Accuracy:** Make sure the information provided is accurate, relevant, and up-to-date. Inaccurate information can lead to distrust and dissatisfaction.\n*   **Expertise:** If possible, involve subject matter experts to ensure the content is reliable and credible. Expert opinions and insights add more value to the content.\n*   **Curation:** Curate your content carefully to avoid information overload, and ensure it remains focused, informative, and useful for your target audience.\n\nDesign and Aesthetics:\n----------------------\n\n*   **Professional design:** A well-designed interface instills confidence in the user. Choose professional-looking fonts, colors, and other design elements that resonate with your target audience.\n*   **Consistency:** Maintain consistency in layout, color schemes, and overall branding. This helps users to associate your content with a familiar and trustworthy organization.\n*   **Navigation:** Ensure the navigation is intuitive and easy to use, helping users to explore your content with confidence.\n\nTestimonials and Social Proof:\n------------------------------\n\n*   **Testimonials:** Share real testimonials from satisfied users/customers to build trust with your audience.\n*   **Case Studies:** Showcase your expertise with detailed case studies that demonstrate your skills and accomplishments.\n*   **Social Proof:** Display social proof by featuring badges, certifications, or collaborations with renowned organizations.\n\nAccessibility and Support:\n--------------------------\n\n*   **Accessibility:** Ensure your content is accessible to everyone, regardless of their abilities, by meeting accessibility standards.\n*   **Customer Support:** Offer easily accessible support options and resources, such as a help center, live chat, or customer service contact information.\n\nTo deploy strong subject authority in your UX design, focus on providing reliable content, maintaining a professional appearance, sharing testimonials and social proof, and offering accessible support. By incorporating these elements into your design, users are more likely to have a positive, intuitive reaction to your product and become loyal, satisfied customers.",
+    "links": []
+  },
+  "m30ePaw_qa36m9Rv9NSFf": {
+    "title": "Be Authentic and Personal",
+    "description": "When creating a user experience (UX) design, it's essential to be authentic and personal. This means that your design should be genuine, truthful, and relatable to your users. By being authentic and personal, you can create a positive intuitive reaction in your users, as they feel connected and engaged with your website or application. Here are some tips to make your UX design authentic and personal:\n\n#### 1\\. Understand your user persona(s)\n\nBefore you start designing, define your target audience and create user personas that represent them. This may include their age, gender, occupation, interests, and pain points. By understanding the different personas, you can create a design that resonates with each of them, meeting their needs and expectations.\n\n#### 2\\. Use natural and conversational language\n\nTo make your design personal, use natural and conversational language that speaks directly to your users. Avoid jargons, buzzwords, or overly formal language that can create a barrier between you and your users. Your users should be able to understand the content and interact with it smoothly.\n\n#### 3\\. Employ appropriate imagery and visuals\n\nTo enhance authenticity, incorporate images and graphics that are relevant and relatable to your target audience. This means using high-quality, real-life pictures of people or objects that genuinely represent your brand or product. Avoid overused stock images, as they can significantly decrease the perceived authenticity of your design.\n\n#### 4\\. Make emotional connections\n\nEmotions play a vital role in creating personal connections with users. In your design, use color schemes, fonts, and visual elements that evoke emotions and encourage users to form an emotional attachment to your product or brand. The more emotionally invested users are, the more positive their intuitive reactions will be.\n\n#### 5\\. Consistency in design elements\n\nAn authentic user experience is characterized by consistency in design elements, including typography, colors, and visual hierarchy. This consistency helps users feel reassured and comfortable, as they can easily understand and navigate through the design.\n\n#### 6\\. Provide personalized experiences\n\nTo create an authentic UX design, offer personalized experiences to your users based on their preferences, browsing history, or other data. This might include recommending content they may be interested in or tailoring the website layout to meet their specific needs.\n\nBy being authentic and personal in your UX design, you can create a positive and memorable experience for your users. By understanding your target audience, using natural language, incorporating engaging visuals, and providing personalized experiences, you can foster user engagement, trust, and loyalty towards your product or brand.",
+    "links": []
+  },
+  "jBQtuiHGl3eyCTZG85Vz5": {
+    "title": "Prime User-Relevant Associations",
+    "description": "Priming user relevant associations is a vital concept in UX design, aiming to create positive associations with various aspects of the user's experience. To achieve this, designers must tap into the cognitive aspects influencing a user's perception, decision-making, and overall satisfaction with the product or service.\n\nUnderstanding User Relevance\n----------------------------\n\nTo prime user-relevant associations, it's essential to first understand the users and their expectations. Conduct user research to identify their motivations, preferences, and context of use. This helps in shaping the product's design and creating experiences that resonate with their specific needs and desires.\n\nCreating Meaningful Experiences\n-------------------------------\n\nFoster meaningful experiences to evoke positive emotions and establish strong resonating associations. This can be done through:\n\n*   Consistent Branding: Provide a cohesive and continuous visual language throughout the experience. Create harmony by using uniform colors, typography, imagery, and overall design system.\n    \n*   Emotional Design: Create memorable experiences by incorporating emotionally-driven visuals, copy, and interactions. Appeal to users' emotions through the use of storytelling, relatability, and various other persuasive techniques.\n    \n*   Design for Real-life Usage: Understand and address user pain points by offering practical solutions. Design for the user's context of use so they find purpose in the product.\n    \n\nReinforcing Positive Associations\n---------------------------------\n\nConstant reinforcement of positive associations is crucial throughout the user journey. This can be achieved by:\n\n*   Timely Feedback: Ensure that the user receives feedback on the outcome of their actions, both for successful and unsuccessful attempts. Use appropriate visual and auditory cues to guide users and reassure them of their progress.\n    \n*   Reward System: Encourage users through rewards - this could be as simple as congratulatory messages or more complex mechanisms like progress bars or achievements.\n    \n*   Personalization: Customize the user experience to each individual user, tailoring the content, visuals, and interactions as per their preference and past behaviors.\n    \n\nBenefits\n--------\n\nBy successfully priming user-relevant associations, designers can:\n\n*   Foster user satisfaction\n*   Build trust and credibility\n*   Establish long-lasting customer relationships\n*   Increase user engagement and product adoption\n*   Encourage brand loyalty\n\nBy closely understanding and addressing users' needs and preferences, UX designers can create favorable conscious evaluations and ultimately lay a solid foundation for a successful user experience.",
+    "links": []
+  },
+  "zXinWCEH4LlYvXekLK0Ju": {
+    "title": "Leverage Loss-Aversion",
+    "description": "Loss aversion is a psychological phenomenon where individuals are more likely to avoid losses than to achieve equivalent gains. In other words, people feel the pain of losing something more strongly than they feel the pleasure of gaining something of equal value. As a UX designer, you can leverage loss aversion to encourage user engagement, increase conversions, and boost overall user satisfaction.\n\nTips for applying loss aversion in UX design:\n---------------------------------------------\n\n*   **Highlight potential losses:** Emphasize the negative consequences of not taking action. For example, instead of focusing on the benefits of signing up for a newsletter, you could stress the valuable insights and opportunities the user will miss out on if they don't subscribe.\n    \n*   **Use time-sensitive offers:** Creating a sense of urgency can be a powerful motivator for users to take action. Limited-time offers, discounts, or exclusive content can tap into users' fear of missing out (FOMO) and prompt them to engage with your product or service.\n    \n*   **Free trials and progress tracking:** Offer free trials with limited features or time frames that encourage users to explore the full potential of your product. Show users the progress they've made during the trial and remind them what they'll lose if they don't upgrade or purchase.\n    \n*   **Saved user data:** Retain user preferences, settings, or shopping cart data for a limited time, and remind them that this information will be lost if they don't act. This can be especially persuasive, as users may have already invested time and effort into customizing their experience.\n    \n*   **Social proof and testimonials:** Showcase the success stories and testimonials of satisfied customers or users. This can create a sense of loss for prospects who may feel like they're falling behind or missing out on the advantages enjoyed by others.\n    \n*   **Risk reversal and guarantees:** Reduce the perceived risk by offering money-back guarantees, free returns, or no-strings-attached trials. By taking away the potential for loss, users may be more likely to give your product or service a try.\n    \n\nRemember, the goal is to create a balanced user experience that informs and helps users make informed decisions, without resorting to manipulative tactics. Use loss aversion thoughtfully and ethically, and always prioritize the needs and emotions of your users.",
+    "links": []
+  },
+  "iKHU0O0z6gCunCgv_aZye": {
+    "title": "Use Peer Comparisons",
+    "description": "Peer comparisons involve using feedback or showcasing how other users, especially those with similar attributes or objectives, are interacting with your product. This can be a powerful tool in influencing user behavior and driving favorable conscious evaluation.\n\nWhy Use Peer Comparisons?\n-------------------------\n\n*   **Social Proof:** Peer comparisons provide social proof of the value of your product, which can reassure users and boost their willingness to adopt it.\n*   **Healthy Competition:** Comparisons with peers can motivate users to improve their performance and fully utilize your product to stay ahead.\n*   **Personal Relevance:** Peer comparisons are more relatable than general statistics or testimonials, since users see the results of others who are in similar situations.\n*   **Guidance:** By observing the actions of their peers, users can learn best practices and common pitfalls, improving their overall experience with your product.\n\nHow to Implement Peer Comparisons\n---------------------------------\n\n*   **Choose Relevant Peers:** To make comparisons meaningful and motivating, focus on users who share key attributes, goals, or contexts with the target user. Tailor the comparisons accordingly.\n*   **Highlight Key Metrics:** Showcase an individual's progress, usage, or success with the product in comparison to their peers. Ensure these metrics are relevant and understandable to your users.\n*   **Provide Context:** Make sure that users can understand why they are being compared to a particular peer group, minimizing potential resentment or disinterest.\n*   **Maintain Anonymity:** To respect user privacy and avoid potential negative experiences, ensure that personal information is not shared without consent.\n*   **Enable Opt-Out:** Users should always have the option to opt out of peer comparisons if they find it intrusive or unhelpful.\n\nCaveats\n-------\n\n*   Be aware that peer comparisons can lead to unintended consequences if not handled properly, such as demotivation, social pressure, or decreased self-esteem.\n*   Always respect user privacy and ensure a positive, supportive environment when implementing peer comparisons in your UX design.\n\nBy effectively leveraging peer comparisons, you can enhance user engagement and satisfaction, ultimately creating a more successful and enjoyable product experience.",
+    "links": []
+  },
+  "6Mvm8SrISyTT99AJ-VFaW": {
+    "title": "Use Competition",
+    "description": "Utilizing competition in UX design can lead to more engaging and motivating user experiences. By incorporating competitive elements, you encourage users to not only interact with your product or system but also compare their performance with others. This comparison can fuel their desire to improve, return to the app, and spend more time on your platform. Below are key points to keep in mind when using competition in UX design:\n\nIdentify appropriate competitive elements\n-----------------------------------------\n\nIt is crucial to determine which competitive elements are suitable for your target audience and the nature of your product. For example:\n\n*   **Leaderboards:** Show rankings of top users based on points or achievements, encouraging users to climb higher in rankings.\n*   **Badges and awards:** Recognize users' achievements by awarding virtual trophies or badges for completing specific tasks.\n*   **Challenges:** Set up periodic or one-time events where users need to complete a task within a certain timeframe to win prizes.\n\nBalance competition with collaboration\n--------------------------------------\n\nEnsure that your UX design balances competition and collaboration. Too much competition can create a hostile environment, while collaboration allows users to support each other and work together. For example, you could have a group leaderboard where users can form teams and compete against other teams or create collaborative challenges where users must work together to succeed collectively.\n\nConsider the target audience\n----------------------------\n\nKeep your target audience in mind when incorporating competitive elements in your UX design. Understand the motivation and preferences of your users to create competition that appeals to them. For example, casual users might prefer low-pressure, friendly competitions, whereas professional or hardcore users might appreciate more intense, skill-based competitions.\n\nBe mindful of negative impacts\n------------------------------\n\nBe aware of the potential for negative implications that competition can bring, such as increased stress or social comparison. To mitigate these, consider:\n\n*   Allowing users to opt-out of competitive features and leaderboards.\n*   Maintaining a friendly and positive tone in your app's language.\n*   Rewarding users for improvements in their performance, rather than just absolute performance levels.\n\nMeasure success\n---------------\n\nEvaluate the effectiveness of the competitive features in your UX design by tracking relevant metrics such as user engagement, time spent in the app, user retention, and user satisfaction. Use this data to iterate and refine the competition aspects based on user feedback and performance.\n\nIn conclusion, using competition in UX design can create engaging experiences that motivate users, encouraging them to delve deeper into your app or platform. By carefully considering your target audience and the potential pitfalls of competition, you will be well on your way to crafting a user experience that keeps users coming back for more.\n\n* * *",
+    "links": []
+  },
+  "4AzPOKXUN32CkgchRMrRY": {
+    "title": "Avoid Cognitive Overhead",
+    "description": "Cognitive overhead refers to the mental effort needed to understand or operate a given system, tool, or interface. In UX design, it is crucial to minimize cognitive overhead to create user-friendly and efficient experiences. The less mental effort a user needs to invest, the more likely they will have a positive conscious evaluation of your design. Here are three key strategies to help you avoid cognitive overhead in your designs:\n\n#### 1\\. Keep it simple\n\nA clutter-free, clean, and easy-to-navigate design is always a good starting point. In order to keep cognitive overhead to a minimum, focus on simplifying both the interface and the content:\n\n*   Utilize white space: By providing ample space between functional elements, you make it easier for users to scan and process the interface.\n*   Reduce the number of options: Offering too many choices can overwhelm users or cause them to second-guess their decisions. Aim for a balance of ease and functionality.\n\n#### 2\\. Establish a clear hierarchy\n\nA well-structured hierarchy helps users navigate your design and understand the relationship between elements. This reduces cognitive overhead as users don't have to work hard to make sense of the interface:\n\n*   Organize content logically: Group related items together and place them in a consistent order.\n*   Use size, color, and typography effectively: Make important information stand out and use visual cues to indicate less important elements.\n\n#### 3\\. Provide clear & concise instructions\n\nYour design should guide users effortlessly, which can be achieved by providing clear directions or prompts:\n\n*   Use actionable language: Be precise and direct with your wording, and avoid using jargon.\n*   Offer visual cues & feedback: Include well-placed icons, highlighted sections, or animation to support the user's actions and indicate the outcome of those actions.\n\nIn summary, reducing cognitive overhead in your UX design is essential to create an efficient and user-friendly experience. Adopt a simple and clean design, establish a clear hierarchy, and provide helpful instructions to ensure more favorable conscious evaluations from your users.",
+    "links": []
+  },
+  "8wxlu4KA2iu9CJa1UAUll": {
+    "title": "Avoid Choice Overload",
+    "description": "Choice overload is a phenomenon that occurs when users are presented with too many options, causing decision paralysis, anxiety, and ultimately, dissatisfaction with their final choice. As a UX designer, it's essential to ensure that users can easily make decisions within your designs, so it's important to avoid choice overload. In this section, we'll discuss some strategies for managing the number of options and streamlining decision-making processes for users.\n\nLimit the Number of Options\n---------------------------\n\nResearch has shown that a user's ability to make decisions decreases as the number of options increases. To avoid overwhelming users, aim to present no more than 5-7 options at a time. This can be applied to menus, product listings, or any other area where users are asked to make a selection. Remember to prioritize the most important or commonly used options and make them more prominent within the design.\n\nCategorize and Organize Options\n-------------------------------\n\nWhen users are presented with multiple choices, it's crucial to make it easy for them to understand and differentiate between the available options. By categorizing and organizing options into logical groups, users can more quickly find the information or functionality they need. Consider using headings, icons, or other visual cues to assist in organizing content effectively.\n\nImplement Smart Defaults\n------------------------\n\nTo help users make decisions quicker, consider setting default selections for certain choices. By pre-selecting the most commonly used or recommended option, users can easily accept the default if it aligns with their needs, or quickly change it if necessary. This not only saves time and effort for the user, but it can also guide them towards an optimal outcome based on their needs.\n\nAdvanced Filtering and Sorting Options\n--------------------------------------\n\nIf your design requires users to make complex decisions, such as choosing a product from an extensive catalog, consider implementing advanced filtering and sorting options. By giving users the ability to refine their options based on specific attributes, they can more easily identify the best option for their needs. Make sure these filtering options are easy to understand and use, and provide clear feedback on the number of results remaining as users adjust their filters.\n\nBy being mindful of choice overload and implementing these strategies, you can create a more enjoyable and user-friendly experience for your users. Remember, the goal is to make their decision-making process as seamless and stress-free as possible.",
+    "links": []
+  },
+  "iQNvKhwhvbis4Yn1ZxQua": {
+    "title": "Avoid Direct Payments",
+    "description": "Avoiding direct payments is a crucial aspect of UX design that can lead to favorable conscious evaluations from users. Direct payments refer to instances where users are required to pay for your product or service upfront, which can create a negative perception and less willingness to engage. By finding alternative ways to monetize or offer premium features, you can create an enjoyable experience and encourage users to appreciate and invest in your offerings without feeling forced.\n\nWhy it Matters?\n---------------\n\n*   **Trust-Building**: When users are not asked to pay upfront or have no hidden costs, they are more likely to trust your product or service, increasing the likelihood of loyal customers.\n*   **Accessibility**: Making your offerings available without direct payments ensures a larger and more diverse audience can experience the value your product provides, which can lead to increased traffic and eventual conversions.\n*   **Reduced churn**: Users who do not feel \"locked-in\" by having to pay upfront are less likely to abandon your product or service in search of alternative solutions.\n\nStrategies to Avoid Direct Payments\n-----------------------------------\n\n*   **Offer a free trial**: Provide users with a limited-time free trial of your product or service to showcase its value and encourage them to invest once the trial is over.\n*   **Freemium model**: Allow users to access basic features of your product for free, while offering premium features at a cost. This model lets users experience your offerings without having to pay upfront and gives them the option to upgrade if they find value in it.\n*   **In-app purchases**: Incorporate in-app purchases within your product, which enables users to access premium features and benefits without being forced to pay upfront.\n*   **Subscriptions**: Offer subscriptions as an alternative payment method that allows users to access premium features and receive updates frequently, creating a sense of loyalty and commitment.\n*   **Pay-as-you-go or usage-based pricing**: Implement a flexible pricing model where users only pay for what they use or when they use a specific feature, removing the barrier of direct payments and increasing user satisfaction.\n\nBy avoiding direct payments and implementing these strategies, a UX designer can create a user experience that fosters trust, accessibility, and user engagement. By doing so, you increase the likelihood of gaining favorable conscious evaluations of your product, ultimately leading to long-term success.",
+    "links": []
+  },
+  "S9rJr8pc-Ln8BxG0suBWa": {
+    "title": "Frame Text to Avoid Temporal Myopia",
+    "description": "Temporal myopia, also known as short-termism, occurs when individuals or organizations prioritize immediate gains over long-term benefits. This focus on the present can lead to suboptimal decisions, negatively impacting the overall user experience (UX) in the long run. As a UX designer, your goal is to avoid temporal myopia and create designs keeping the long-term user experience in mind.\n\nLong-term vs. Short-term UX\n---------------------------\n\nIt's essential to balance short-term goals, such as increasing conversions or sales, with long-term UX objectives, such as user satisfaction and loyalty. Consider the following when avoiding temporal myopia in your designs:\n\n#### 1\\. Sustainable Design Solutions\n\nDesign for both the present and future by creating sustainable design solutions that adapt to evolving user needs and technology advancements. This approach will ensure a seamless experience across different contexts and platforms, catering to growth and change.\n\n#### 2\\. Prioritize User Needs\n\nUnderstand and prioritize user needs throughout the development process. Strive to balance business objectives with end-user satisfaction, focusing on designing experiences that create lasting value for both parties.\n\n#### 3\\. Iterate and Test\n\nAdopt a continuous improvement mindset and emphasize the importance of iteration and testing in the design process. This approach will enable you to refine and perfect your designs over time, addressing any negative impacts of short-term decisions and meeting long-term user requirements.\n\n#### 4\\. User Feedback\n\nIncorporate user feedback into your design process, gathering insights from diverse sources such as usability testing, surveys, and customer reviews. Analyzing user feedback will help you identify elements that contribute to a positive long-term experience and can inform your design choices.\n\n#### 5\\. Build Trust and Loyalty\n\nDesign experiences that foster trust and loyalty with users, including employing principles of personalization, security, transparency, and accessibility. Establishing long-term relationships with users will help you better understand their needs and adapt your designs as their requirements change over time.\n\nBy avoiding temporal myopia in your UX design process, you'll create experiences that cater to both immediate and long-term user needs while fostering trust and loyalty. Balancing short-term gains with a long-term user-centric focus will help you deliver designs that stand the test of time and provide lasting value to both users and organizations.",
+    "links": []
+  },
+  "kR-UbUFdELVeiPJqT0GlZ": {
+    "title": "Remind of Prior Commitment to Act",
+    "description": "Sometimes, users need a gentle reminder of the commitments or decisions they've made in the past to help them move forward in their user journey. As a UX designer, you can incorporate these reminders to create a sense of urgency and promote desired actions from users.\n\nBenefits of Reminding Users of Prior Commitments\n------------------------------------------------\n\n*   **Motivate users to act**: When reminded of a commitment they've already made, users are more likely to follow through with the action, especially if they feel they've invested time or resources toward that action.\n*   **Create a sense of urgency**: By emphasizing the importance of their commitments, users are more likely to prioritize their tasks and act sooner.\n*   **Promote consistency**: Reminding users of their prior commitments can promote consistency in their behavior and decision-making, leading to a better user experience.\n\nStrategies to Remind Users of Prior Commitments\n-----------------------------------------------\n\n*   **Display progress indicators**: Show users how far they have come in a process, such as filling out a form or completing a survey, to remind them of their progress so far.\n*   **Use notifications**: Send timely notifications or reminders to remind users of their prior commitments, such as appointments they made or tasks they wished to complete.\n*   **Leverage personalized content**: Customize content to emphasize a user's previous actions, for example, by showing related products based on prior purchases, or pre-filling forms with previously entered data.\n*   **Create social proof**: Showcase testimonials, reviews, or follower counts to remind users of their decision to join a community or use a product, creating a sense of belonging and reinforcing their initial commitment.\n\nBy incorporating reminders of prior commitments in the user experience, you can make users feel more invested in the process, create a sense of urgency, and ultimately, improve the overall UX design.",
+    "links": []
+  },
+  "dOL2z6ULpmzRD5N3MrYCy": {
+    "title": "Make Commitment to Friends",
+    "description": "One of the key strategies to create a sense of urgency in your UX design is to encourage users to make commitments with their friends. This approach leverages the power of social influence and personal accountability to drive user engagement and action.\n\nWhy it's effective\n------------------\n\n*   **Social Proof:** When users see that their friends have already made a commitment, they are more likely to follow suit. This creates a sense of social validation and peer pressure, which can nudge users towards making similar decisions.\n*   **Accountability:** Making a commitment with friends can increase a user's sense of responsibility and dedication to follow through on their decision. Knowing that their actions are being observed by others makes backing out less attractive, hence increasing the chances of users following through on their commitments.\n\nHow to implement it in your UX design\n-------------------------------------\n\n*   **Show friend's activity:** Design your interface to portray commitments and actions made by friends. For example, social media platforms often show a user's friends who have already signed up for an event or have endorsed a product.\n*   **Enable sharing:** Make it easy for users to share their commitments, interests, or goals with their friends. This could include features like sharing buttons or personalized social media posts.\n*   **Create group goals:** Allow users to commit to a shared goal together. Design experiences that encourage collaboration and teamwork, such as group challenges or competitions.\n*   **Offer incentives for group commitments:** Reward users for achieving goals together, for example, offering discounts or exclusive features for a group of friends who sign up for a service together.\n\nBy incorporating the \"make commitment to friends\" concept in your UX design, you can tap into people's natural tendencies of social conformity and accountability. This encourages users to engage with your product, convert to actions, and more importantly, stick around for the long haul.",
+    "links": []
+  },
+  "1pzONoWafLAeX8eWbH-Dz": {
+    "title": "Make Reward Scarce",
+    "description": "One of the effective techniques to create urgency in UX design is to make rewards scarce. Making a reward scarce means limiting its availability in terms of quantity or time. This scarcity increases its perceived value leading to urgency among users to act fast in order to avail the reward. Here, we'll discuss some strategies to make rewards scarce in your design:\n\nLimited Quantity\n----------------\n\nIntroduce rewards with limited quantities, making users feel that they need to act fast before the rewards are gone. This exerts psychological pressure as users do not want to miss out on the opportunity.\n\n_Example_: You can offer a limited quantity promotion wherein the first 50 customers to make a purchase receive a bonus gift or a special discount.\n\nLimited Time Offers\n-------------------\n\nCreating time-based limitations on rewards is another effective way to increase urgency. The inherent nature of time works its magic by encouraging users to be quick to avoid missing out on the reward.\n\n_Example_: Flash sales, 24-hour promotions and countdown timers are examples of limited-time offers that create urgency to buy now or miss out on the deal.\n\nExclusive Access\n----------------\n\nOffering exclusive access to specific features, content or experiences for a limited number of users not only increases perceived value but also adds a sense of exclusivity.\n\n_Example_: Granting access to a members-only online event, beta release of an application, or special product launches can create urgency to sign-up or purchase for the privilege of having that exclusive access.\n\nSeasonal Rewards\n----------------\n\nAlign the rewards with seasons, events, or holidays, creating a natural sense of scarcity due to the time-bound nature of these events.\n\n_Example_: Offering discounts, special promotions, or limited edition items connected to holidays or events like Christmas, Valentine's Day, Black Friday, etc., can create a sense of urgency as users are aware that these opportunities only come around once a year.\n\nRemember to apply these strategies ethically and transparently when designing experiences in your application. Creating genuine scarcity and urgency will ensure that your users value your offers and continue to engage with your product.",
+    "links": []
+  },
+  "EmDgiwaknBz5lXr1rwalE": {
+    "title": "Elicit Implementation Intentions",
+    "description": "Eliciting implementation intentions is a powerful technique used in UX design to help users achieve their goals while using your platform or product. Implementation intentions are formed when users are encouraged to think about and plan specific actions they will take to reach a desired outcome. By incorporating prompts and guidance for users to make these plans, you can boost their chances of success and improve overall user satisfaction. In this section, we will discuss how to effectively elicit implementation intentions.\n\nWhy Implementation Intentions Matter\n------------------------------------\n\nNumerous studies show that when people form implementation intentions, they are more likely to follow through with their plans and achieve their goals. Instead of just having a vague idea of what they want to accomplish, users with implementation intentions have a clear roadmap of how and when to take action. This removes much of the guesswork and ambiguity that can hinder success and can make your UX design more effective at helping users achieve their desired outcomes.\n\nHow to Elicit Implementation Intentions\n---------------------------------------\n\nTo encourage users to form implementation intentions, you'll want to create prompts and guidance within your UX design that help them identify and plan for the specific actions they will take. Here are some tips to help you do this:\n\n*   **Break down goals into subtasks**: To help users make plans, divide their overarching goal into smaller, more manageable subtasks. Present these subtasks clearly within your design and encourage users to think about how and when they will complete them.\n    \n*   **Provide clear instructions**: Offer step-by-step guidance to help users accomplish each subtask. This can take the form of tooltips, onboarding flows, or even simple checklists.\n    \n*   **Set attainable deadlines**: Encourage users to set specific deadlines for when they will complete each subtask. Including a built-in calendar or scheduling functionality can help make this process more seamless.\n    \n*   **Create reminders and notifications**: Incorporate reminder mechanisms into your design to help users stay on track with their plans. This can include push notifications, email reminders, or in-app alerts.\n    \n*   **Track progress**: Make it easy for users to track their progress toward goal completion. Visual aids, such as progress bars and checklists, go a long way in helping users see how far they've come and encouraging them to keep going.\n    \n*   **Offer encouragement and feedback**: Positive reinforcement can help keep users motivated and engaged with their plans. Congratulate users on milestones reached and provide feedback on their progress.\n    \n\nBy incorporating these strategies into your UX design, you can foster an environment that supports users in forming implementation intentions and helps them achieve their goals more effectively. Remember, the easier it is for users to make plans and take actionable steps towards their objectives, the more successful and satisfied they will be with your product.",
+    "links": []
+  },
+  "wE5gt1vMgbF3csA61VO2-": {
+    "title": "Default Everything",
+    "description": "One of the key principles in UX design is to **make it easy for users** by creating a seamless and intuitive interface. One effective way to achieve this is by implementing **default settings** for various user actions and input fields. Default settings not only simplify the decision-making process but also save time and prevent errors. In this section, we will discuss the importance of default settings and provide some practical tips for implementing them in your UX design.\n\n#### Why are default settings important?\n\n*   **Save time and effort:** Defaults reduce the cognitive load on the user, as they don't have to manually set options while interacting with your product. They can quickly proceed without worrying about customizing every single element.\n    \n*   **Increase usability:** Defaults make it easier for users to use your product without needing to understand the complexities involved. This is especially helpful for new users who are still exploring your product and might be overwhelmed by too many options.\n    \n*   **Reduce errors:** Errors are more likely to occur when users have to configure complex settings manually. Providing default options minimizes the chances of error and ensures a smoother experience.\n    \n\n#### Tips for implementing default settings in your UX design:\n\n*   **Choose sensible defaults:** It's essential to carefully consider which default settings are most appropriate for your target user group. Keep their needs and preferences in mind while making these choices.\n    \n*   **Allow customization:** While providing default settings, it's crucial to give users the flexibility to change these settings as per their needs. Make sure that customization options are easily accessible so that users can modify them if required.\n    \n*   **Set progressive defaults:** Progressive defaults adjust over time based on a user's behavior and choices. For example, if a user always selects a specific option, make that the new default for that user. This personalizes the experience and demonstrates that your product is actively adapting to the user's preferences.\n    \n*   **Test your defaults:** It's important to test and validate your default settings to ensure that they benefit your users. Collect feedback, conduct user testing, and iterate to find the most effective defaults for your product.\n    \n\nBy implementing default settings in your UX design, you'll simplify the user's experience and make it easier for them to interact with your product. By choosing the right defaults and constantly testing and refining them, you'll provide a more satisfying and efficient experience for your users.",
+    "links": []
+  },
+  "gf7et64xCqkYBrP9HwWs_": {
+    "title": "Lessen the Burden of Action / Info",
+    "description": "The goal of \"lessening the burden of action information\" is to simplify and streamline the user experience so that users can efficiently accomplish their tasks without confusion or frustration. Here are some key ways to do this:\n\n*   #### Provide Clear Instructions\n    \n    Clearly communicate to your users what they need to do. Ensure language is clear, concise and easily understood. This reduces the chances of users feeling lost or not knowing what to do.\n*   #### Minimize Steps\n    \n    Reduce the number of steps or actions users need to take in order to complete a task. This not only simplifies the process but also saves users' time and effort.\n*   #### Declutter Interface\n    \n    Remove unnecessary elements from your interface that might distract or confuse your users. Focus on presenting only the essential information and UI components, which will allow your users to navigate and interact more easily.\n*   #### Group Related Actions\n    \n    Organize similar actions and options together. This helps users understand the logical flow of completing a task and makes the interface easier to navigate.\n*   #### Break Down Complex Tasks\n    \n    Break complex tasks into smaller, more manageable sub-tasks or steps. This helps users understand the overall process better and allows them to focus on one step at a time.\n*   #### Make Default Values Meaningful\n    \n    Set default values that make sense and help users to complete actions more quickly. This saves users the time and effort of manually entering or selecting values in certain cases.\n\nBy implementing these techniques in your UX design, you will make it easier for users to interact with and complete tasks within your product, leading to a more satisfying and successful experience.",
+    "links": []
+  },
+  "gqOnzmiLQHmIXuEe4jG2e": {
+    "title": "Deploy Peer Comparisons",
+    "description": "Deploying peer comparisons in UX design involves showing users how their actions or decisions stack up against those of other users in a similar context. This technique can be highly effective in motivating users to take desired actions, especially when backed by strong social proof. It's crucial, however, to implement peer comparisons in a way that is both ethical and user-friendly. Let's explore key considerations and best practices for including peer comparisons in your UX design.\n\nBenefits of Peer Comparisons\n----------------------------\n\n*   **Motivation** - Users often feel encouraged to take desired actions when they see peers doing the same. This phenomenon is called social proof, a powerful motivator for persuasive design.\n*   **Informative** - Comparisons can provide users with valuable insights, such as how they rank against peers or how much improvement they can make.\n*   **Friendly Competition** - Peer comparisons can introduce a healthy sense of competition among users, which can lead to positive outcomes.\n\nBest Practices for Deploying Peer Comparisons\n---------------------------------------------\n\n*   **Ensure Relevance** - Make sure the peer comparisons displayed are relevant and useful to the user. Irrelevant comparisons can lead to confusion or frustration.\n*   **Don't Shame Users** - Avoid designing comparisons that put users down in any way. Focus on creating a positive experience and highlighting the benefits of adopting desired behaviors.\n*   **Respect Privacy** - Be mindful of users' privacy by obtaining consent before displaying their personal data or comparing their actions with others.\n*   **Provide Opt-Out Options** - Give users the choice to remove themselves from peer comparisons or view comparisons anonymously.\n*   **Avoid Overwhelming Users** - Display comparisons sparingly and thoughtfully. Excessive peer comparisons can be overwhelming or counterproductive.\n\nBy carefully implementing peer comparisons in your UX design, you can effectively motivate users to take desired actions, while maintaining a positive and intuitive user experience. Remember to be considerate of users' privacy and preferences when introducing this powerful technique.",
+    "links": []
+  },
+  "GgBazWfF2OvOqkuo3DO2L": {
+    "title": "Measuring the Impact",
+    "description": "Measuring the impact of UX design is crucial to understand its effectiveness and make necessary improvements. In this section, we'll explore the key metrics, methods, and tools to help you measure the impact of your UX design efforts.\n\nKey Metrics\n-----------\n\nSeveral metrics can help you find out whether your UX design is meeting the objectives. Some prominent ones include:\n\n*   **User satisfaction**: Gather feedback through surveys, ratings, or interviews to evaluate users' satisfaction with your design.\n*   **Task completion**: Measure the percentage of users who can complete specific tasks within the design without trouble.\n*   **Completion time**: Analyze the time taken by users to complete tasks, indicating efficiency and ease of use.\n*   **Error rate**: Track the number of errors users make while interacting with your design to assess usability.\n*   **Conversion rate**: Calculate the percentage of users who achieve the targeted action (sign-ups, purchases, etc.) to measure design effectiveness.\n\nMethods of Measurement\n----------------------\n\nVarious methods can be employed to measure the impact of UX design, such as:\n\n*   **Usability testing**: Conduct tests with real users to observe their interactions with your design, identify issues and improvement areas.\n*   **A/B testing**: Compare two different versions of your design to determine which one better meets your objectives.\n*   **Heatmaps**: Visualize user interactions (clicks, taps, scrolls) within your design to identify popular areas and potential trouble spots.\n*   **User surveys and interviews**: Collect qualitative data on user satisfaction, preferences, and pain points to assess the design's impact.\n\nTools for Measuring Impact\n--------------------------\n\nSeveral tools can assist you in measuring the impact of your UX design, including:\n\n*   **Google Analytics**: A free tool to track user behavior, such as conversion rates, bounce rates, and user flows within your design.\n*   **Hotjar**: A popular tool to create heatmaps, collect user feedback, and record user sessions for analysis.\n*   **Optimizely**: A platform for A/B testing, multivariate testing, and personalization of your design.\n*   **UsabilityHub**: A user testing platform that offers a range of tools to test your design, including first-click tests, preference tests, and five-second tests.\n\nBy regularly measuring the impact of your UX design and analyzing the gathered data, you can effectively enhance your design, ensuring positive user experiences and achieving your business goals.",
+    "links": []
+  },
+  "Q4xBz9f3yyZi2F_aZ5ixL": {
+    "title": "Incremental A/B Testing",
+    "description": "Incremental A/B testing is the process of testing small design, content, or functionality changes in your user experience (UX) design to evaluate their impact on your conversion goals. Instead of making a large, sweeping change to your design, incremental A/B testing focuses on smaller, iterative changes that can be measured and analyzed. This approach has several benefits:\n\nReduced Risk\n------------\n\nBy making smaller, more focused changes, you can reduce the risk associated with bigger changes that may affect several aspects of your design. This allows you to isolate specific elements of the user experience and determine the impact of your changes more accurately.\n\nEasier Implementation\n---------------------\n\nIncremental changes are typically easier to implement and test, which can lead to shorter development cycles and a quicker turnaround time on improvements. This can help you save valuable resources, such as time and budget, while improving your UX design.\n\nMore Data-Based Insights\n------------------------\n\nSince incremental A/B testing generates more specific and focused results, you can gather more data-based insights to help you make better, informed decisions on your UX design. This can lead to a more targeted approach when making future design improvements.\n\nHow to Conduct Incremental A/B Testing:\n---------------------------------------\n\n**Step 1: Identify Your Goal**\n\nBefore you begin testing, you need to have a clear understanding of the goal you are trying to achieve with your incremental change. This could be increasing conversion rates, reducing bounce rates, or improving user engagement.\n\n**Step 2: Define a Hypothesis**\n\nDevelop a hypothesis for each change. Your hypothesis should be based on research and data and should clearly state your expected outcome from the incremental change.\n\n**Step 3: Design and Implement Changes**\n\nDesign and implement your changes in line with your hypothesis. Keep your changes specific, targeted, and incremental to improve data accuracy and make implementation easier.\n\n**Step 4: Set up A/B Testing**\n\nUse a reliable A/B testing tool to set up your testing environment. Ensure that you have a control version (without changes) and a treatment version (with changes) to compare within the test.\n\n**Step 5: Analyze and Interpret Results**\n\nOnce you've completed your test, analyze the results to determine if your incremental change has had the desired impact on your goal. Evaluate the data and make decisions based on your findings.\n\n**Step 6: Iterate and Improve**\n\nBased on your results, iterate and make improvements to your UX design. Continue running incremental A/B tests as you fine-tune your design to achieve the best possible user experience.\n\nBy making use of incremental A/B testing, you thoroughly understand the impact of each small change in your UX design, which empowers you to create an optimized user experience and reach your conversion goals effectively.",
+    "links": []
+  },
+  "-_T2nzp1vV1jUcpsC5DI3": {
+    "title": "Multivariate Testing",
+    "description": "Multivariate testing is an advanced user testing method that allows designers to test multiple elements or variations within a single test. Its primary goal is to identify the best-performing variations among several competing design alternatives. Multivariate testing provides insights on how different design variations impact user experience and conversions, and helps in identifying which combination of elements works best for your users.\n\nHow it Works\n------------\n\nIn a multivariate test, several design variations are presented to different groups of users simultaneously. The test seeks to measure the performance of each design variation utilizing clearly-defined metrics like conversion rates, number of clicks, or user engagement. Data is collected and analyzed to determine which variation has the greatest positive impact on those pre-identified metrics.\n\nKey Advantages\n--------------\n\n*   **Optimization**: Multivariate testing enables designers to optimize their designs by identifying the best-performing variations for each element. This ultimately leads to improved overall performance of the user interface.\n*   **Increased Confidence**: By comparing multiple design elements simultaneously, designers can gather data-driven insights to make informed decisions, increasing confidence in their design choices.\n*   **Efficiency**: Multivariate testing enables designers to test several elements in a single test. This saves time, effort, and resources compared to testing each element individually.\n\nWhen to Use Multivariate Testing\n--------------------------------\n\n*   **Complex Designs or High Traffic**: Multivariate testing is particularly suitable for complex designs with multiple combinations, or situations when the design is expected to generate high traffic.\n*   **Confirming Best-Performing Variations**: When simplistic A/B testing does not provide enough information to determine which variation is the best, multivariate testing can provide deeper insights.\n*   **When Hypotheses are Uncertain**: If you're unsure which design element is responsible for driving desired user behavior, a multivariate test can provide valuable information to guide your design decisions.\n\nThings to Consider\n------------------\n\nMultivariate testing may require a larger user sample size compared to A/B testing, as more variations of the design are being analyzed. Additionally, this method works best when there is sufficient traffic or a high volume of user engagement.\n\nKeep in mind that while multivariate testing can provide valuable insights, it's important not to lose sight of the big picture. Focus on testing elements that are truly critical to your design goals and prioritize user feedback at every stage of the process.",
+    "links": []
+  },
+  "Emby09Nsm_j6uNreT58r6": {
+    "title": "Gather Lessons, Prioritize & Integrate",
+    "description": "One of the most important aspects of measuring the impact of UX design is to gather lessons, prioritize them, and integrate them into future iterations. This process ensures that you're continuously improving your product design and user experience.\n\nGather Lessons\n--------------\n\nThe first step in this process is to gather the lessons you've learned as a result of your UX design impact measurements. You should take note of both the strong and weak points of your current design. Some methods to gather these lessons include user feedback, quantitative data from usability tests, and qualitative insights from user interviews or surveys. Collecting this data helps you to get a comprehensive understanding of what is working well and what needs improvements in your product design.\n\nPrioritize\n----------\n\nAfter gathering the lessons, it's crucial to identify and prioritize the most important issues that need to be addressed. Prioritization can be based on various factors, such as the severity of the issue, the number of users affected, the effort required for the improvement, and the potential impact on user satisfaction.\n\nTo help with prioritization, you can make use of methods such as:\n\n*   Impact-Effort Matrix: Rank issues based on their potential impact on users and the effort required to resolve them.\n*   MoSCoW Method: Classify issues as \"Must-Have,\" \"Should-Have,\" \"Could-Have,\" or \"Won't-Have.\"\n*   Kano Model: Identify issues that will delight users, satisfy their basic needs, or cause dissatisfaction if not addressed.\n\nBy prioritizing issues, you'll be able to allocate the right resources and time to solve them effectively.\n\nIntegrate\n---------\n\nOnce you have prioritized the key issues, the next step is to integrate them into your product roadmap and design process. This means addressing these issues during iteration planning, incorporating them into your design requirements, and working closely with your development team to ensure they're implemented appropriately.\n\nMonitoring the progress and evaluating the impact of these changes in subsequent iterations is also important. This will help you validate the success of your efforts and provide valuable insights for continuous improvement.\n\nTo summarize, gathering lessons, prioritizing, and integrating them into your UX design process is essential for measuring the impact and knowing the areas of improvement. By continuously iterating and learning from user feedback and data, you can build a more effective and engaging product for your users.",
+    "links": []
+  }
+}

readme.md

@@ -36,12 +36,14 @@ Here is the list of available roadmaps with more being actively worked upon.
 - [Backend Roadmap](https://roadmap.sh/backend) / [Backend Beginner Roadmap](https://roadmap.sh/backend?r=backend-beginner)
 - [DevOps Roadmap](https://roadmap.sh/devops) / [DevOps Beginner Roadmap](https://roadmap.sh/devops?r=devops-beginner)
 - [Full Stack Roadmap](https://roadmap.sh/full-stack)
+- [Git and GitHub](https://roadmap.sh/git-github)
 - [API Design Roadmap](https://roadmap.sh/api-design)
 - [Computer Science Roadmap](https://roadmap.sh/computer-science)
 - [Data Structures and Algorithms Roadmap](https://roadmap.sh/datastructures-and-algorithms)
 - [AI and Data Scientist Roadmap](https://roadmap.sh/ai-data-scientist)
 - [AWS Roadmap](https://roadmap.sh/aws)
 - [Linux Roadmap](https://roadmap.sh/linux)
+- [Terraform Roadmap](https://roadmap.sh/terraform)
 - [Data Analyst Roadmap](https://roadmap.sh/data-analyst)
 - [MLOps Roadmap](https://roadmap.sh/mlops)
 - [Product Manager Roadmap](https://roadmap.sh/product-manager)
@@ -69,6 +71,7 @@ Here is the list of available roadmaps with more being actively worked upon.
 - [Design System Roadmap](https://roadmap.sh/design-system)
 - [PostgreSQL Roadmap](https://roadmap.sh/postgresql-dba)
 - [SQL Roadmap](https://roadmap.sh/sql)
+- [Redis Roadmap](https://roadmap.sh/redis)
 - [Blockchain Roadmap](https://roadmap.sh/blockchain)
 - [ASP.NET Core Roadmap](https://roadmap.sh/aspnet-core)
 - [System Design Roadmap](https://roadmap.sh/system-design)
@@ -79,6 +82,7 @@ Here is the list of available roadmaps with more being actively worked upon.
 - [Docker Roadmap](https://roadmap.sh/docker)
 - [Prompt Engineering Roadmap](https://roadmap.sh/prompt-engineering)
 - [Technical Writer Roadmap](https://roadmap.sh/technical-writer)
+- [DevRel Engineer Roadmap](https://roadmap.sh/devrel)
 
 There are also interactive best practices:
 

scripts/compress-images.ts

@@ -90,9 +90,6 @@ const COMPRESS_CONFIG = {
       case '.avif':
         imageBuffer = await sharp(image).avif(COMPRESS_CONFIG.avif).toBuffer();
         break;
-      case '.gif':
-        imageBuffer = await sharp(image).gif(COMPRESS_CONFIG.gif).toBuffer();
-        break;
       case '.heif':
         imageBuffer = await sharp(image).heif().toBuffer();
         break;
@@ -111,6 +108,8 @@ const COMPRESS_CONFIG = {
       case '.webp':
         imageBuffer = await sharp(image).webp(COMPRESS_CONFIG.webp).toBuffer();
         break;
+      case '.gif':
+        continue;
     }
 
     if (!imageBuffer) {

scripts/editor-roadmap-content-json.ts

@@ -0,0 +1,184 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { Node } from 'reactflow';
+import matter from 'gray-matter';
+import type { RoadmapFrontmatter } from '../src/lib/roadmap';
+import { slugify } from '../src/lib/slugger';
+import { markdownToHtml } from '../src/lib/markdown';
+import { HTMLElement, parse } from 'node-html-parser';
+import { htmlToMarkdown } from '../src/lib/html';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const allowedLinkTypes = [
+  'video',
+  'article',
+  'opensource',
+  'course',
+  'website',
+  'podcast',
+] as const;
+
+// Directory containing the roadmaps
+const ROADMAP_CONTENT_DIR = path.join(__dirname, '../src/data/roadmaps');
+const allRoadmaps = await fs.readdir(ROADMAP_CONTENT_DIR);
+
+const editorRoadmapIds = new Set<string>();
+for (const roadmapId of allRoadmaps) {
+  const roadmapFrontmatterDir = path.join(
+    ROADMAP_CONTENT_DIR,
+    roadmapId,
+    `${roadmapId}.md`,
+  );
+  const roadmapFrontmatterRaw = await fs.readFile(
+    roadmapFrontmatterDir,
+    'utf-8',
+  );
+  const { data } = matter(roadmapFrontmatterRaw);
+
+  const roadmapFrontmatter = data as RoadmapFrontmatter;
+  if (roadmapFrontmatter.renderer === 'editor') {
+    editorRoadmapIds.add(roadmapId);
+  }
+}
+
+const publicRoadmapsContentDir = path.join('./public', 'roadmap-content');
+const stats = await fs.stat(publicRoadmapsContentDir).catch(() => null);
+if (!stats || !stats.isDirectory()) {
+  await fs.mkdir(publicRoadmapsContentDir, { recursive: true });
+}
+
+for (const roadmapId of editorRoadmapIds) {
+  console.log(`🚀 Starting ${roadmapId}`);
+
+  const roadmapDir = path.join(
+    ROADMAP_CONTENT_DIR,
+    roadmapId,
+    `${roadmapId}.json`,
+  );
+  const roadmapContent = await fs.readFile(roadmapDir, 'utf-8');
+  let { nodes } = JSON.parse(roadmapContent) as {
+    nodes: Node[];
+  };
+  nodes = nodes.filter(
+    (node) =>
+      node?.type &&
+      ['topic', 'subtopic', 'todo'].includes(node.type) &&
+      node.data?.label,
+  );
+
+  const roadmapContentDir = path.join(
+    ROADMAP_CONTENT_DIR,
+    roadmapId,
+    'content',
+  );
+  const stats = await fs.stat(roadmapContentDir).catch(() => null);
+  if (!stats || !stats.isDirectory()) {
+    await fs.mkdir(roadmapContentDir, { recursive: true });
+  }
+
+  const roadmapContentFiles = await fs.readdir(roadmapContentDir, {
+    recursive: true,
+  });
+
+  const contentMap: Record<
+    string,
+    {
+      title: string;
+      description: string;
+      links: {
+        title: string;
+        url: string;
+        type: string;
+      }[];
+    }
+  > = {};
+
+  for (const node of nodes) {
+    const ndoeDirPatterWithoutExt = `${slugify(node.data.label)}@${node.id}`;
+    const nodeDirPattern = `${ndoeDirPatterWithoutExt}.md`;
+    if (!roadmapContentFiles.includes(nodeDirPattern)) {
+      contentMap[nodeDirPattern] = {
+        title: node.data.label,
+        description: '',
+        links: [],
+      };
+
+      continue;
+    }
+
+    const content = await fs.readFile(
+      path.join(roadmapContentDir, nodeDirPattern),
+      'utf-8',
+    );
+    const html = markdownToHtml(content, false);
+    const rootHtml = parse(html);
+
+    let ulWithLinks: HTMLElement | undefined;
+    rootHtml.querySelectorAll('ul').forEach((ul) => {
+      const listWithJustLinks = Array.from(ul.querySelectorAll('li')).filter(
+        (li) => {
+          const link = li.querySelector('a');
+          return link && link.textContent?.trim() === li.textContent?.trim();
+        },
+      );
+
+      if (listWithJustLinks.length > 0) {
+        ulWithLinks = ul;
+      }
+    });
+
+    const listLinks =
+      ulWithLinks !== undefined
+        ? Array.from(ulWithLinks.querySelectorAll('li > a'))
+            .map((link) => {
+              const typePattern = /@([a-z.]+)@/;
+              let linkText = link.textContent || '';
+              const linkHref = link.getAttribute('href') || '';
+              let linkType = linkText.match(typePattern)?.[1] || 'article';
+              linkType = allowedLinkTypes.includes(linkType as any)
+                ? linkType
+                : 'article';
+
+              linkText = linkText.replace(typePattern, '');
+
+              return {
+                title: linkText,
+                url: linkHref,
+                type: linkType,
+              };
+            })
+            .sort((a, b) => {
+              const order = [
+                'official',
+                'opensource',
+                'article',
+                'video',
+                'feed',
+              ];
+              return order.indexOf(a.type) - order.indexOf(b.type);
+            })
+        : [];
+
+    const title = rootHtml.querySelector('h1');
+    ulWithLinks?.remove();
+    title?.remove();
+    const htmlStringWithoutLinks = rootHtml.toString();
+    const description = htmlToMarkdown(htmlStringWithoutLinks);
+
+    contentMap[node.id] = {
+      title: node.data.label,
+      description,
+      links: listLinks,
+    };
+  }
+
+  await fs.writeFile(
+    path.join(publicRoadmapsContentDir, `${roadmapId}.json`),
+    JSON.stringify(contentMap, null, 2),
+  );
+  console.log(`✅ Finished ${roadmapId}`);
+  console.log('-'.repeat(20));
+}

scripts/generate-og-images.mjs

@@ -372,7 +372,7 @@ function getRoadmapDefaultTemplate({ title, description }) {
               </svg>
             </div>
             <div tw="text-[30px] flex leading-[30px]">
-              6th most starred GitHub project
+              7th most starred GitHub project
             </div>
           </div>
           <div tw="flex items-center mt-2.5">

src/api/leaderboard.ts

@@ -0,0 +1,38 @@
+import { type APIContext } from 'astro';
+import { api } from './api.ts';
+
+export type LeaderboardUserDetails = {
+  id: string;
+  name: string;
+  avatar?: string;
+  count: number;
+};
+
+export type ListLeaderboardStatsResponse = {
+  streaks: {
+    active: LeaderboardUserDetails[];
+    lifetime: LeaderboardUserDetails[];
+  };
+  projectSubmissions: {
+    currentMonth: LeaderboardUserDetails[];
+    lifetime: LeaderboardUserDetails[];
+  };
+  githubContributors: {
+    currentMonth: LeaderboardUserDetails[];
+  };
+  referrals: {
+    currentMonth: LeaderboardUserDetails[];
+    lifetime: LeaderboardUserDetails[];
+  };
+};
+
+export function leaderboardApi(context: APIContext) {
+  return {
+    listLeaderboardStats: async function () {
+      return api(context).get<ListLeaderboardStatsResponse>(
+        `${import.meta.env.PUBLIC_API_URL}/v1-list-leaderboard-stats`,
+        {},
+      );
+    },
+  };
+}

src/api/project.ts

@@ -0,0 +1,15 @@
+import { type APIContext } from 'astro';
+import { api } from './api.ts';
+
+export function projectApi(context: APIContext) {
+  return {
+    listProjectsUserCount: async function (projectIds: string[]) {
+      return api(context).post<Record<string, number>>(
+        `${import.meta.env.PUBLIC_API_URL}/v1-list-projects-user-count`,
+        {
+          projectIds,
+        },
+      );
+    },
+  };
+}

src/api/roadmap.ts

@@ -0,0 +1,67 @@
+import { type APIContext } from 'astro';
+import { api } from './api.ts';
+import type { RoadmapDocument } from '../components/CustomRoadmap/CreateRoadmap/CreateRoadmapModal.tsx';
+import type { PageType } from '../components/CommandMenu/CommandMenu.tsx';
+
+export type ListShowcaseRoadmapResponse = {
+  data: Pick<
+    RoadmapDocument,
+    | '_id'
+    | 'title'
+    | 'description'
+    | 'slug'
+    | 'creatorId'
+    | 'visibility'
+    | 'createdAt'
+    | 'topicCount'
+    | 'ratings'
+  >[];
+  totalCount: number;
+  totalPages: number;
+  currPage: number;
+  perPage: number;
+};
+
+export function roadmapApi(context: APIContext) {
+  return {
+    listShowcaseRoadmap: async function () {
+      const searchParams = new URLSearchParams(context.url.searchParams);
+      return api(context).get<ListShowcaseRoadmapResponse>(
+        `${import.meta.env.PUBLIC_API_URL}/v1-list-showcase-roadmap`,
+        searchParams,
+      );
+    },
+    isShowcaseRoadmap: async function (slug: string) {
+      return api(context).get<{
+        isShowcase: boolean;
+      }>(`${import.meta.env.PUBLIC_API_URL}/v1-is-showcase-roadmap/${slug}`);
+    },
+  };
+}
+
+export type ProjectPageType = {
+  id: string;
+  title: string;
+  url: string;
+};
+
+export async function getProjectList() {
+  const baseUrl = import.meta.env.DEV
+    ? 'http://localhost:3000'
+    : 'https://roadmap.sh';
+  const pages = await fetch(`${baseUrl}/pages.json`).catch((err) => {
+    console.error(err);
+    return [];
+  });
+
+  const pagesJson = await (pages as any).json();
+  const projects: ProjectPageType[] = pagesJson
+    .filter((page: any) => page?.group?.toLowerCase() === 'projects')
+    .map((page: any) => ({
+      id: page.id,
+      title: page.title,
+      url: page.url,
+    }));
+
+  return projects;
+}

src/api/user.ts

@@ -1,6 +1,7 @@
 import { type APIContext } from 'astro';
 import { api } from './api.ts';
 import type { ResourceType } from '../lib/resource-progress.ts';
+import type { ProjectStatusDocument } from '../components/Projects/ListProjectSolutions.tsx';
 
 export const allowedRoadmapVisibility = ['all', 'none', 'selected'] as const;
 export type AllowedRoadmapVisibility =
@@ -44,6 +45,7 @@ export interface UserDocument {
     github?: string;
     linkedin?: string;
     twitter?: string;
+    dailydev?: string;
     website?: string;
   };
   username?: string;
@@ -98,6 +100,7 @@ export type GetPublicProfileResponse = Omit<
 > & {
   activity: UserActivityCount;
   roadmaps: ProgressResponse[];
+  projects: ProjectStatusDocument[];
   isOwnProfile: boolean;
 };
 

src/components/AIAnnouncement.tsx

@@ -1,16 +0,0 @@
-type AIAnnouncementProps = {};
-
-export function AIAnnouncement(props: AIAnnouncementProps) {
-  return (
-    <a
-      className="rounded-md border border-dashed border-purple-600 px-3 py-1.5 text-purple-400 transition-colors hover:border-purple-400 hover:text-purple-200"
-      href="/ai"
-    >
-      <span className="relative -top-[1px] mr-1 text-xs font-semibold uppercase text-white">
-        New
-      </span>{' '}
-      <span className={'hidden sm:inline'}>Generate visual roadmaps with AI</span>
-      <span className={'inline text-sm sm:hidden'}>AI Roadmap Generator!</span>
-    </a>
-  );
-}

src/components/AccountStreak/AccountStreak.tsx

@@ -0,0 +1,189 @@
+import { useEffect, useRef, useState } from 'react';
+import { isLoggedIn } from '../../lib/jwt';
+import { httpGet } from '../../lib/http';
+import { useToast } from '../../hooks/use-toast';
+import { Zap, ZapOff } from 'lucide-react';
+import { useOutsideClick } from '../../hooks/use-outside-click';
+import { StreakDay } from './StreakDay';
+import {
+  navigationDropdownOpen,
+  roadmapsDropdownOpen,
+} from '../../stores/page.ts';
+import { useStore } from '@nanostores/react';
+import { cn } from '../../lib/classname.ts';
+import { $accountStreak, type StreakResponse } from '../../stores/streak.ts';
+import { InviteFriends } from './InviteFriends.tsx';
+
+type AccountStreakProps = {};
+
+export function AccountStreak(props: AccountStreakProps) {
+  const toast = useToast();
+  const dropdownRef = useRef(null);
+
+  const [isLoading, setIsLoading] = useState(true);
+  const accountStreak = useStore($accountStreak);
+  const [showDropdown, setShowDropdown] = useState(false);
+
+  const $roadmapsDropdownOpen = useStore(roadmapsDropdownOpen);
+  const $navigationDropdownOpen = useStore(navigationDropdownOpen);
+
+  useEffect(() => {
+    if ($roadmapsDropdownOpen || $navigationDropdownOpen) {
+      setShowDropdown(false);
+    }
+  }, [$roadmapsDropdownOpen, $navigationDropdownOpen]);
+
+  const loadAccountStreak = async () => {
+    if (!isLoggedIn()) {
+      return;
+    }
+
+    if (accountStreak) {
+      setIsLoading(false);
+      return;
+    }
+
+    setIsLoading(true);
+    const { response, error } = await httpGet<StreakResponse>(
+      `${import.meta.env.PUBLIC_API_URL}/v1-streak`,
+    );
+
+    if (error || !response) {
+      toast.error(error?.message || 'Failed to load account streak');
+      setIsLoading(false);
+      return;
+    }
+
+    $accountStreak.set(response);
+    setIsLoading(false);
+  };
+
+  useOutsideClick(dropdownRef, () => {
+    setShowDropdown(false);
+  });
+
+  useEffect(() => {
+    loadAccountStreak().finally(() => {});
+  }, []);
+
+  if (!isLoggedIn() || isLoading) {
+    return null;
+  }
+
+  let { count: currentCount = 0 } = accountStreak || {};
+  const previousCount =
+    accountStreak?.previousCount || accountStreak?.count || 0;
+
+  // Adding one to show the current day
+  const currentCircleCount = Math.min(currentCount, 5) + 1;
+  // Adding one day to show the streak they broke
+  const leftCircleCount = Math.min(5 - currentCircleCount, previousCount) + 1;
+  // In the maximum case, we will show 10 circles
+  const remainingCount = Math.max(0, 10 - leftCircleCount - currentCircleCount);
+  const totalCircles = leftCircleCount + currentCircleCount + remainingCount;
+
+  return (
+    <div className="relative z-[90] animate-fade-in">
+      <button
+        className={cn(
+          'flex items-center justify-center rounded-lg p-1.5 px-2 text-purple-400 hover:bg-purple-100/10 focus:outline-none',
+          {
+            'bg-purple-100/10': showDropdown,
+          },
+        )}
+        onClick={() => setShowDropdown(true)}
+      >
+        <Zap strokeWidth={1} className="size-5 fill-current" />
+        <span className="ml-1.5 text-sm font-semibold">
+          {accountStreak?.count}
+        </span>
+      </button>
+
+      {showDropdown && (
+        <div
+          ref={dropdownRef}
+          className="absolute right-0 top-full z-50 w-[335px] translate-y-1 rounded-lg bg-slate-800 shadow-xl"
+        >
+          <div className="py-5 pl-4 pr-5">
+            <div className="flex items-center justify-between gap-2 text-sm text-slate-500">
+              <p>
+                Current Streak
+                <span className="ml-2 font-medium text-white">
+                  {accountStreak?.count || 0}
+                </span>
+              </p>
+              <p>
+                Longest Streak
+                <span className="ml-2 font-medium text-white">
+                  {accountStreak?.longestCount || 0}
+                </span>
+              </p>
+            </div>
+
+            <div className="mb-6 mt-9">
+              <div className="grid grid-cols-10 gap-1">
+                {Array.from({ length: totalCircles }).map((_, index) => {
+                  let dayCount,
+                    icon,
+                    isPreviousStreakDay,
+                    isBrokenStreakDay,
+                    isCurrentStreakDay,
+                    isRemainingStreakDay,
+                    isToday;
+
+                  if (index < leftCircleCount) {
+                    // Previous streak days
+                    dayCount = previousCount - leftCircleCount + index + 1 + 1;
+                    isPreviousStreakDay = true;
+                    isBrokenStreakDay = index === leftCircleCount - 1;
+
+                    icon = isBrokenStreakDay ? (
+                      <ZapOff className="size-5 fill-current" />
+                    ) : (
+                      <Zap className="size-5 fill-current" />
+                    );
+                  } else if (index < leftCircleCount + currentCircleCount) {
+                    // Current streak days
+                    const currentIndex = index - leftCircleCount;
+                    dayCount =
+                      currentCount - currentCircleCount + currentIndex + 1 + 1;
+                    isCurrentStreakDay = true;
+                    isToday = currentIndex === currentCircleCount - 1;
+                    icon = <Zap className="size-5 fill-current" />;
+                  } else {
+                    // Remaining streak days
+                    const remainingIndex =
+                      index - leftCircleCount - currentCircleCount;
+                    dayCount = currentCount + remainingIndex + 1 + 1;
+                    isRemainingStreakDay = true;
+                  }
+
+                  return (
+                    <StreakDay
+                      key={`streak-${index}`}
+                      dayCount={dayCount}
+                      icon={icon}
+                      isBrokenStreakDay={isBrokenStreakDay}
+                      isPreviousStreakDay={isPreviousStreakDay}
+                      isCurrentStreakDay={isCurrentStreakDay}
+                      isRemainingStreakDay={isRemainingStreakDay}
+                      isToday={isToday}
+                    />
+                  );
+                })}
+              </div>
+            </div>
+
+            <p className="-mt-[0px] mb-[1.5px] text-center text-xs tracking-wide text-slate-500">
+              Visit every day to keep your streak going!
+            </p>
+
+            <InviteFriends
+              refByUserCount={accountStreak?.refByUserCount || 0}
+            />
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

src/components/AccountStreak/AccountStreakHeatmap.css

@@ -0,0 +1,7 @@
+.react-calendar-heatmap text {
+  fill: rgb(148, 163, 184) !important;
+}
+
+.react-calendar-heatmap rect:hover {
+  stroke: rgb(148, 163, 184) !important;
+}

src/components/AccountStreak/AccountStreakHeatmap.tsx

@@ -0,0 +1,189 @@
+import CalendarHeatmap from 'react-calendar-heatmap';
+import dayjs from 'dayjs';
+import { formatActivityDate } from '../../lib/date';
+import { Tooltip as ReactTooltip } from 'react-tooltip';
+import 'react-calendar-heatmap/dist/styles.css';
+import './AccountStreakHeatmap.css';
+
+const legends = [
+  { count: 1, color: 'bg-slate-600' },
+  { count: 3, color: 'bg-slate-500' },
+  { count: 5, color: 'bg-slate-400' },
+  { count: 10, color: 'bg-slate-300' },
+  { count: 20, color: 'bg-slate-200' },
+];
+
+type AccountStreakHeatmapProps = {};
+
+export function AccountStreakHeatmap(props: AccountStreakHeatmapProps) {
+  const startDate = dayjs().subtract(6, 'months').toDate();
+  const endDate = dayjs().toDate();
+
+  return (
+    <div className="mt-4">
+      <CalendarHeatmap
+        startDate={startDate}
+        endDate={endDate}
+        values={[
+          {
+            date: '2024-08-01',
+            count: 4,
+          },
+          {
+            date: '2024-08-02',
+            count: 10,
+          },
+          {
+            date: '2024-08-03',
+            count: 5,
+          },
+          {
+            date: '2024-08-04',
+            count: 3,
+          },
+          {
+            date: '2024-08-05',
+            count: 7,
+          },
+          {
+            date: '2024-08-06',
+            count: 2,
+          },
+          {
+            date: '2024-08-07',
+            count: 6,
+          },
+          {
+            date: '2024-08-08',
+            count: 8,
+          },
+          {
+            date: '2024-08-09',
+            count: 9,
+          },
+          {
+            date: '2024-08-10',
+            count: 1,
+          },
+          {
+            date: '2024-08-11',
+            count: 3,
+          },
+          {
+            date: '2024-08-12',
+            count: 5,
+          },
+          {
+            date: '2024-08-13',
+            count: 7,
+          },
+          {
+            date: '2024-08-14',
+            count: 8,
+          },
+          {
+            date: '2024-08-15',
+            count: 2,
+          },
+          {
+            date: '2024-08-16',
+            count: 4,
+          },
+          {
+            date: '2024-08-17',
+            count: 6,
+          },
+          {
+            date: '2024-08-18',
+            count: 8,
+          },
+          {
+            date: '2024-08-19',
+            count: 10,
+          },
+          {
+            date: '2024-08-20',
+            count: 2,
+          },
+          {
+            date: '2024-08-21',
+            count: 4,
+          },
+          {
+            date: '2024-08-22',
+            count: 6,
+          },
+          {
+            date: '2024-08-23',
+            count: 8,
+          },
+          {
+            date: '2024-08-24',
+            count: 10,
+          },
+          {
+            date: '2024-08-25',
+            count: 30,
+          },
+        ]}
+        classForValue={(value) => {
+          if (!value) {
+            return 'fill-slate-700 rounded-md [rx:2px] focus:outline-none';
+          }
+
+          const { count } = value;
+          if (count >= 20) {
+            return 'fill-slate-200 rounded-md [rx:2px] focus:outline-none';
+          } else if (count >= 10) {
+            return 'fill-slate-300 rounded-md [rx:2px] focus:outline-none';
+          } else if (count >= 5) {
+            return 'fill-slate-400 rounded-md [rx:2px] focus:outline-none';
+          } else if (count >= 3) {
+            return 'fill-slate-500 rounded-md [rx:2px] focus:outline-none';
+          } else {
+            return 'fill-slate-600 rounded-md [rx:2px] focus:outline-none';
+          }
+        }}
+        tooltipDataAttrs={(value: any) => {
+          if (!value || !value.date) {
+            return null;
+          }
+
+          const formattedDate = formatActivityDate(value.date);
+          return {
+            'data-tooltip-id': 'user-activity-tip',
+            'data-tooltip-content': `${value.count} Updates - ${formattedDate}`,
+          };
+        }}
+      />
+
+      <ReactTooltip
+        id="user-activity-tip"
+        className="!rounded-lg !bg-slate-900 !p-1 !px-2 !text-xs"
+      />
+
+      <div className="mt-2 flex items-center justify-end">
+        <div className="flex items-center">
+          <span className="mr-2 text-xs text-slate-500">Less</span>
+          {legends.map((legend) => (
+            <div
+              key={legend.count}
+              className="flex items-center"
+              data-tooltip-id="user-activity-tip"
+              data-tooltip-content={`${legend.count} Updates`}
+            >
+              <div
+                className={`h-2.5 w-2.5 ${legend.color} mr-1 rounded-sm`}
+              ></div>
+            </div>
+          ))}
+          <span className="ml-2 text-xs text-slate-500">More</span>
+          <ReactTooltip
+            id="user-activity-tip"
+            className="!rounded-lg !bg-slate-900 !p-1 !px-2 !text-sm"
+          />
+        </div>
+      </div>
+    </div>
+  );
+}

src/components/AccountStreak/InviteFriends.tsx

@@ -0,0 +1,88 @@
+import { Copy, Heart } from 'lucide-react';
+import { useAuth } from '../../hooks/use-auth';
+import { useCopyText } from '../../hooks/use-copy-text';
+import { cn } from '../../lib/classname';
+import { CheckIcon } from '../ReactIcons/CheckIcon';
+import { TrophyEmoji } from '../ReactIcons/TrophyEmoji.tsx';
+
+type InviteFriendsProps = {
+  refByUserCount: number;
+};
+
+export function InviteFriends(props: InviteFriendsProps) {
+  const { refByUserCount } = props;
+
+  const user = useAuth();
+  const { copyText, isCopied } = useCopyText();
+
+  const referralLink = new URL(
+    `/signup?rc=${user?.id}`,
+    import.meta.env.DEV ? 'http://localhost:3000' : 'https://roadmap.sh',
+  ).toString();
+
+  return (
+    <div className="-mx-4 mt-6 flex flex-col border-t border-dashed border-t-slate-600 px-4 pt-5 text-center text-sm">
+      <p className="text-slate-500">Invite people to join roadmap.sh</p>
+
+      <div className="flex flex-col items-center rounded-lg bg-slate-900/40 pb-4 pt-5 my-4">
+        <p className="text-xs text-slate-500">
+          {refByUserCount === 0 && <>You haven't invited anyone yet.</>}
+          {refByUserCount > 0 && refByUserCount < 10 && (
+            <>{refByUserCount} of 10 users joined</>
+          )}
+        </p>
+
+        {refByUserCount >= 10 && <>🎉 You've invited {refByUserCount} users</>}
+
+        <div className="my-3 flex flex-row items-center justify-center gap-1">
+          {Array.from({ length: 10 }).map((_, index) => (
+            <Heart
+              key={index}
+              className={cn(
+                'size-[23px] fill-current',
+                index < refByUserCount ? 'text-yellow-300' : 'text-slate-700',
+              )}
+            />
+          ))}
+        </div>
+        <p className={'mb-3 text-xs text-slate-500'}>
+          Share the link below with anyone you think would benefit from using
+          roadmap.sh
+        </p>
+        <p className="text-slate-500">
+          <button
+            onClick={() => {
+              copyText(referralLink);
+            }}
+            className={cn(
+              'rounded-md hover:bg-slate-500/80 hover:text-slate-100 px-3 py-1 text-xs text-slate-300 bg-slate-600',
+              {
+                'bg-green-500 text-black hover:text-black hover:bg-green-500': isCopied,
+              },
+            )}
+          >
+            {!isCopied ? 'Copy Invite Link' : 'Invite Link Copied'}{' '}
+            {!isCopied && (
+              <Copy
+                className="relative -top-[1.25px] ml-1.5 inline-block size-3"
+                strokeWidth={3}
+              />
+            )}
+            {isCopied && (
+              <CheckIcon additionalClasses="relative ml-1.5 -top-[1.25px] inline-block size-3" />
+            )}
+          </button>
+        </p>
+      </div>
+
+      <p className="text-center text-xs">
+        <a
+          href="/leaderboard"
+          className="text-purple-400 underline-offset-2 hover:underline"
+        >
+          See how you rank on the leaderboard
+        </a>
+      </p>
+    </div>
+  );
+}

src/components/AccountStreak/StreakDay.tsx

@@ -0,0 +1,52 @@
+import type { ReactNode } from 'react';
+import { cn } from '../../lib/classname';
+import { ChevronDown } from 'lucide-react';
+
+type StreakDayProps = {
+  isToday?: boolean;
+  isCurrentStreakDay?: boolean;
+  isPreviousStreakDay?: boolean;
+  isBrokenStreakDay?: boolean;
+  isRemainingStreakDay?: boolean;
+  dayCount: number;
+  icon?: ReactNode;
+};
+
+export function StreakDay(props: StreakDayProps) {
+  const {
+    isCurrentStreakDay,
+    isPreviousStreakDay,
+    isBrokenStreakDay,
+    isRemainingStreakDay,
+    dayCount,
+    icon,
+    isToday = false,
+  } = props;
+
+  return (
+    <div
+      className={cn(
+        'relative flex flex-col items-center justify-center gap-1.5',
+        {
+          'text-red-400 opacity-40': isPreviousStreakDay,
+          'text-slate-600': isRemainingStreakDay,
+          'text-yellow-300': isCurrentStreakDay,
+          'text-slate-400': isToday,
+        },
+      )}
+    >
+      <div
+        className={cn('flex size-6 items-center justify-center rounded-full', {
+          'bg-slate-700': isRemainingStreakDay,
+          'border border-dashed border-slate-500 striped-bg': isToday,
+        })}
+      >
+        {isToday ? null : icon}
+      </div>
+      <span className={cn('text-xs')}>{dayCount}</span>
+      {isToday && (
+        <ChevronDown className="absolute bottom-full left-1/2 h-3.5 w-3.5 -translate-y-[0.75px] -translate-x-1/2 transform stroke-[2.5px] text-slate-400" />
+      )}
+    </div>
+  );
+}

src/components/Activity/ActivityPage.tsx

@@ -5,6 +5,10 @@ import { ResourceProgress } from './ResourceProgress';
 import { pageProgressMessage } from '../../stores/page';
 import { EmptyActivity } from './EmptyActivity';
 import { ActivityStream, type UserStreamActivity } from './ActivityStream';
+import type { ProjectStatusDocument } from '../Projects/ListProjectSolutions';
+import type { PageType } from '../CommandMenu/CommandMenu';
+import { useToast } from '../../hooks/use-toast';
+import { ProjectProgress } from './ProjectProgress';
 
 type ProgressResponse = {
   updatedAt: string;
@@ -47,11 +51,14 @@ export type ActivityResponse = {
     };
   }[];
   activities: UserStreamActivity[];
+  projects: ProjectStatusDocument[];
 };
 
 export function ActivityPage() {
+  const toast = useToast();
   const [activity, setActivity] = useState<ActivityResponse>();
   const [isLoading, setIsLoading] = useState(true);
+  const [projectDetails, setProjectDetails] = useState<PageType[]>([]);
 
   async function loadActivity() {
     const { error, response } = await httpGet<ActivityResponse>(
@@ -68,11 +75,29 @@ export function ActivityPage() {
     setActivity(response);
   }
 
+  async function loadAllProjectDetails() {
+    const { error, response } = await httpGet<PageType[]>(`/pages.json`);
+
+    if (error) {
+      toast.error(error.message || 'Something went wrong');
+      return;
+    }
+
+    if (!response) {
+      return [];
+    }
+
+    const allProjects = response.filter((page) => page.group === 'Projects');
+    setProjectDetails(allProjects);
+  }
+
   useEffect(() => {
-    loadActivity().finally(() => {
-      pageProgressMessage.set('');
-      setIsLoading(false);
-    });
+    Promise.allSettled([loadActivity(), loadAllProjectDetails()]).finally(
+      () => {
+        pageProgressMessage.set('');
+        setIsLoading(false);
+      },
+    );
   }, []);
 
   const learningRoadmaps = activity?.learning.roadmaps || [];
@@ -106,6 +131,17 @@ export function ActivityPage() {
     learningRoadmapsToShow.length !== 0 ||
     learningBestPracticesToShow.length !== 0;
 
+  const enrichedProjects = activity?.projects.map((project) => {
+    const projectDetail = projectDetails.find(
+      (page) => page.id === project.projectId,
+    );
+
+    return {
+      ...project,
+      title: projectDetail?.title || 'N/A',
+    };
+  });
+
   return (
     <>
       <ActivityCounters
@@ -201,6 +237,19 @@ export function ActivityPage() {
         )}
       </div>
 
+      {enrichedProjects && enrichedProjects?.length > 0 && (
+        <div className="mx-0 px-0 py-5 pb-0 md:-mx-10 md:px-8 md:py-8 md:pb-0">
+          <h2 className="mb-3 text-xs uppercase text-gray-400">
+            Your Projects
+          </h2>
+          <div className="grid grid-cols-1 gap-1.5 sm:grid-cols-2">
+            {enrichedProjects.map((project) => (
+              <ProjectProgress key={project._id} projectStatus={project} />
+            ))}
+          </div>
+        </div>
+      )}
+
       {hasProgress && (
         <ActivityStream activities={activity?.activities || []} />
       )}

src/components/Activity/ProjectProgress.tsx

@@ -0,0 +1,57 @@
+import { getUser } from '../../lib/jwt';
+import { getPercentage } from '../../helper/number';
+import { ProjectProgressActions } from './ProjectProgressActions';
+import { cn } from '../../lib/classname';
+import type { ProjectStatusDocument } from '../Projects/ListProjectSolutions';
+import { ProjectStatus } from './ProjectStatus';
+import { ThumbsUp } from 'lucide-react';
+
+type ProjectProgressType = {
+  projectStatus: ProjectStatusDocument & {
+    title: string;
+  };
+  showActions?: boolean;
+  userId?: string;
+};
+
+export function ProjectProgress(props: ProjectProgressType) {
+  const {
+    projectStatus,
+    showActions = true,
+    userId: defaultUserId = getUser()?.id,
+  } = props;
+
+  const shouldShowActions =
+    projectStatus.submittedAt &&
+    projectStatus.submittedAt !== null &&
+    showActions;
+
+  return (
+    <div className="relative">
+      <a
+        className={cn(
+          'group relative flex w-full items-center justify-between overflow-hidden rounded-md border border-gray-300 bg-white px-3 py-2 pr-7 text-left text-sm transition-all hover:border-gray-400',
+          shouldShowActions ? '' : 'pr-3',
+        )}
+        href={`/projects/${projectStatus.projectId}`}
+        target="_blank"
+      >
+        <ProjectStatus projectStatus={projectStatus} />
+        <span className="ml-2 flex-grow truncate">{projectStatus?.title}</span>
+        <span className="inline-flex items-center gap-1 text-xs text-gray-400">
+          {projectStatus.upvotes}
+          <ThumbsUp className="size-2.5 stroke-[2.5px]" />
+        </span>
+      </a>
+
+      {shouldShowActions && (
+        <div className="absolute right-2 top-0 flex h-full items-center">
+          <ProjectProgressActions
+            userId={defaultUserId!}
+            projectId={projectStatus.projectId}
+          />
+        </div>
+      )}
+    </div>
+  );
+}

src/components/Activity/ProjectProgressActions.tsx

@@ -0,0 +1,68 @@
+import { MoreVertical, X } from 'lucide-react';
+import { useRef, useState } from 'react';
+import { useOutsideClick } from '../../hooks/use-outside-click';
+import { useKeydown } from '../../hooks/use-keydown';
+import { cn } from '../../lib/classname';
+import { useCopyText } from '../../hooks/use-copy-text';
+import { CheckIcon } from '../ReactIcons/CheckIcon';
+import { ShareIcon } from '../ReactIcons/ShareIcon';
+
+type ProjectProgressActionsType = {
+  userId: string;
+  projectId: string;
+};
+
+export function ProjectProgressActions(props: ProjectProgressActionsType) {
+  const { userId, projectId } = props;
+
+  const dropdownRef = useRef<HTMLDivElement>(null);
+  const [isOpen, setIsOpen] = useState(false);
+
+  const { copyText, isCopied } = useCopyText();
+
+  const projectSolutionUrl = `${import.meta.env.DEV ? 'http://localhost:3000' : 'https://roadmap.sh'}/projects/${projectId}/solutions?u=${userId}`;
+
+  useOutsideClick(dropdownRef, () => {
+    setIsOpen(false);
+  });
+
+  useKeydown('Escape', () => {
+    setIsOpen(false);
+  });
+
+  return (
+    <div className="relative h-full" ref={dropdownRef}>
+      <button
+        className="h-full text-gray-400 hover:text-gray-700"
+        onClick={() => setIsOpen(!isOpen)}
+      >
+        <MoreVertical size={16} />
+      </button>
+
+      {isOpen && (
+        <div className="absolute right-0 top-8 z-10 w-48 overflow-hidden rounded-md border border-gray-200 bg-white shadow-lg">
+          <button
+            className={cn(
+              'flex w-full items-center gap-1.5 p-2 text-xs font-medium hover:bg-gray-100 disabled:cursor-not-allowed disabled:opacity-70 sm:text-sm',
+              isCopied ? 'text-green-500' : 'text-gray-500 hover:text-black',
+            )}
+            onClick={() => {
+              copyText(projectSolutionUrl);
+            }}
+          >
+            {isCopied ? (
+              <>
+                <CheckIcon additionalClasses="h-3.5 w-3.5" /> Link Copied
+              </>
+            ) : (
+              <>
+                <ShareIcon className="h-3.5 w-3.5 stroke-[2.5px]" /> Share
+                Solution
+              </>
+            )}
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}

src/components/Activity/ProjectStatus.tsx

@@ -0,0 +1,24 @@
+import { CircleDashed } from 'lucide-react';
+import type { ProjectStatusDocument } from '../Projects/ListProjectSolutions';
+import { CheckIcon } from '../ReactIcons/CheckIcon';
+
+type ProjectStatusType = {
+  projectStatus: ProjectStatusDocument & {
+    title: string;
+  };
+};
+
+export function ProjectStatus(props: ProjectStatusType) {
+  const { projectStatus } = props;
+
+  const { submittedAt, repositoryUrl } = projectStatus;
+  const status = submittedAt && repositoryUrl ? 'submitted' : 'started';
+
+  if (status === 'submitted') {
+    return <CheckIcon additionalClasses="size-3 text-gray-500 shrink-0" />;
+  }
+
+  return (
+    <CircleDashed className="size-3 shrink-0 stroke-[2.5px] text-gray-400" />
+  );
+}

src/components/AdvertiseForm.tsx

@@ -0,0 +1,227 @@
+import React, { useState } from 'react';
+import { CheckIcon } from './ReactIcons/CheckIcon.tsx';
+import { pageProgressMessage } from '../stores/page.ts';
+import { httpPost } from '../lib/http.ts';
+
+type InputProps = {
+  label: string;
+  name: string;
+  type: string;
+  value: string;
+  onChange: (
+    e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,
+  ) => void;
+  required?: boolean;
+  rows?: number;
+};
+
+function Input(props: InputProps) {
+  const { label, name, type, value, onChange, required, rows } = props;
+  return (
+    <div className="mb-4">
+      <label htmlFor={name} className="block text-sm font-medium text-gray-700">
+        {label} {required && <span className="text-red-500">*</span>}
+      </label>
+      {type === 'textarea' ? (
+        <textarea
+          placeholder={label}
+          id={name}
+          name={name}
+          value={value}
+          onChange={onChange}
+          rows={rows}
+          className="mt-1 block w-full rounded-md border border-gray-300 p-2 shadow-sm focus:border-indigo-500 focus:ring-indigo-500 sm:text-sm"
+          autoComplete="off"
+          data-1p-ignore=""
+          data-form-type="other"
+          data-lpignore="true"
+        ></textarea>
+      ) : (
+        <input
+          type={type}
+          id={name}
+          placeholder={label}
+          name={name}
+          value={value}
+          onChange={onChange}
+          required={required}
+          className="mt-1 block w-full rounded-md border border-gray-300 p-2 shadow-sm focus:border-indigo-500 focus:ring-indigo-500 sm:text-sm"
+          autoComplete="off"
+          data-1p-ignore=""
+          data-form-type="other"
+          data-lpignore="true"
+        />
+      )}
+    </div>
+  );
+}
+
+export function AdvertiseForm() {
+  const [status, setStatus] = useState<'submitting' | 'submitted'>();
+  const [error, setError] = useState<string | null>(null);
+
+  const [formData, setFormData] = useState({
+    firstName: '',
+    lastName: '',
+    title: '',
+    company: '',
+    email: '',
+    phone: '',
+    message: '',
+    updates: false,
+  });
+
+  const handleInputChange = (
+    e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>,
+  ) => {
+    const { name, value, type, checked } = e.target as any;
+    setFormData({
+      ...formData,
+      [name]: type === 'checkbox' ? checked : value,
+    });
+  };
+
+  async function handleSubmit(e: React.FormEvent) {
+    e.preventDefault();
+
+    pageProgressMessage.set('Please wait');
+
+    // Placeholder function to send data
+    console.log('Form data:', formData);
+
+    const { response, error } = await httpPost(
+      `${import.meta.env.PUBLIC_API_URL}/v1-advertise`,
+      formData,
+    );
+    if (!response || error) {
+      pageProgressMessage.set('');
+      setError(error?.message || 'Something went wrong. Please try again.');
+      return;
+    }
+
+    setStatus('submitted');
+    pageProgressMessage.set('');
+  }
+
+  if (status === 'submitted') {
+    return (
+      <div className="flex flex-col items-center justify-center rounded-md border bg-gray-50 p-12 text-center">
+        <CheckIcon additionalClasses="h-12 w-12 text-green-500 mb-5" />
+        <h2 className="text-balance text-xl font-semibold text-gray-900">
+          Thank you for your interest in advertising with roadmap.sh
+        </h2>
+        <p className="mt-2 text-sm text-gray-500">
+          We will get back to you soon.
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <>
+      <h2 className="mb-5 text-balance text-2xl font-bold">
+        Ready to learn more? Fill out the form below to get started!
+      </h2>
+      {error && (
+        <div className="relative mb-4 rounded border border-red-400 bg-red-100 px-4 py-3 text-red-700">
+          {error}
+        </div>
+      )}
+      <form className="mb-5" onSubmit={handleSubmit}>
+        <div className="grid gap-0 sm:grid-cols-2 sm:gap-4">
+          <Input
+            label="First Name"
+            name="firstName"
+            type="text"
+            value={formData.firstName}
+            onChange={handleInputChange}
+            required
+          />
+          <Input
+            label="Last Name"
+            name="lastName"
+            type="text"
+            value={formData.lastName}
+            onChange={handleInputChange}
+            required
+          />
+        </div>
+
+        <div className="grid gap-0 sm:grid-cols-2 sm:gap-4">
+          <Input
+            label="Title"
+            name="title"
+            type="text"
+            value={formData.title}
+            onChange={handleInputChange}
+            required
+          />
+
+          <Input
+            label="Company"
+            name="company"
+            type="text"
+            value={formData.company}
+            onChange={handleInputChange}
+            required
+          />
+        </div>
+
+        <div className="grid gap-0 sm:grid-cols-2 sm:gap-4">
+          <Input
+            label="Email"
+            name="email"
+            type="email"
+            value={formData.email}
+            onChange={handleInputChange}
+            required
+          />
+
+          <Input
+            label="Phone"
+            name="phone"
+            type="tel"
+            value={formData.phone}
+            onChange={handleInputChange}
+          />
+        </div>
+
+        <Input
+          label="Message (Optional)"
+          name="message"
+          type="textarea"
+          value={formData.message}
+          onChange={handleInputChange}
+          rows={4}
+        />
+        <div className="mb-4 flex items-start">
+          <div className="flex h-5 items-center">
+            <input
+              id="updates"
+              name="updates"
+              type="checkbox"
+              checked={formData.updates}
+              onChange={handleInputChange}
+              className="h-4 w-4 rounded border-gray-300 text-indigo-600 focus:ring-indigo-500"
+            />
+          </div>
+          <div className="ml-3 text-sm">
+            <label htmlFor="updates" className="font-medium text-gray-700">
+              I want to receive occasional updates about new products or
+              advertising opportunities with roadmap.sh
+            </label>
+          </div>
+        </div>
+
+        <div>
+          <button
+            type="submit"
+            className="flex justify-center rounded-md border border-transparent bg-indigo-600 px-4 py-2 text-sm font-medium text-white shadow-sm hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:ring-offset-2"
+          >
+            Send
+          </button>
+        </div>
+      </form>
+    </>
+  );
+}

src/components/AuthenticationFlow/EmailLoginForm.tsx

@@ -1,6 +1,6 @@
 import Cookies from 'js-cookie';
 import type { FormEvent } from 'react';
-import { useState } from 'react';
+import { useId, useState } from 'react';
 import { httpPost } from '../../lib/http';
 import { TOKEN_COOKIE_NAME, setAuthToken } from '../../lib/jwt';
 
@@ -53,12 +53,16 @@ export function EmailLoginForm(props: EmailLoginFormProps) {
     setError(error?.message || 'Something went wrong. Please try again later.');
   };
 
+  const emailFieldId = `form:${useId()}`;
+  const passwordFieldId = `form:${useId()}`;
+
   return (
     <form className="w-full" onSubmit={handleFormSubmit}>
-      <label htmlFor="email" className="sr-only">
+      <label htmlFor={emailFieldId} className="sr-only">
         Email address
       </label>
       <input
+        id={emailFieldId}
         name="email"
         type="email"
         autoComplete="email"
@@ -68,10 +72,11 @@ export function EmailLoginForm(props: EmailLoginFormProps) {
         value={email}
         onInput={(e) => setEmail(String((e.target as any).value))}
       />
-      <label htmlFor="password" className="sr-only">
+      <label htmlFor={passwordFieldId} className="sr-only">
         Password
       </label>
       <input
+        id={passwordFieldId}
         name="password"
         type="password"
         autoComplete="current-password"

src/components/AuthenticationFlow/EmailSignupForm.tsx

@@ -1,5 +1,7 @@
-import { type FormEvent, useState } from 'react';
+import { type FormEvent, useEffect, useState } from 'react';
 import { httpPost } from '../../lib/http';
+import { deleteUrlParam, getUrlParams } from '../../lib/browser';
+import { isLoggedIn, setAIReferralCode } from '../../lib/jwt';
 
 type EmailSignupFormProps = {
   isDisabled?: boolean;
@@ -9,6 +11,9 @@ type EmailSignupFormProps = {
 export function EmailSignupForm(props: EmailSignupFormProps) {
   const { isDisabled, setIsDisabled } = props;
 
+  const { rc: referralCode } = getUrlParams() as {
+    rc?: string;
+  };
   const [email, setEmail] = useState('');
   const [password, setPassword] = useState('');
   const [name, setName] = useState('');
@@ -47,6 +52,16 @@ export function EmailSignupForm(props: EmailSignupFormProps) {
     )}`;
   };
 
+  useEffect(() => {
+    if (!referralCode || isLoggedIn()) {
+      deleteUrlParam('rc');
+      return;
+    }
+
+    setAIReferralCode(referralCode);
+    deleteUrlParam('rc');
+  }, []);
+
   return (
     <form className="flex w-full flex-col gap-2" onSubmit={onSubmit}>
       <label htmlFor="name" className="sr-only">
@@ -72,7 +87,7 @@ export function EmailSignupForm(props: EmailSignupFormProps) {
         type="email"
         autoComplete="email"
         required
-        className="block w-full rounded-lg border border-gray-300 px-3 py-2  outline-none placeholder:text-gray-400 focus:ring-2 focus:ring-black focus:ring-offset-1"
+        className="block w-full rounded-lg border border-gray-300 px-3 py-2 outline-none placeholder:text-gray-400 focus:ring-2 focus:ring-black focus:ring-offset-1"
         placeholder="Email Address"
         value={email}
         onInput={(e) => setEmail(String((e.target as any).value))}

src/components/AuthenticationFlow/TriggerVerifyEmail.tsx

@@ -73,7 +73,7 @@ export function TriggerVerifyEmail() {
           Verifying your new Email
         </h2>
         <div className="text-sm sm:text-base">
-          {isLoading && <p>Please wait while we verify your new Email..</p>}
+          {isLoading && <p>Please wait while we verify your new Email.</p>}
           {error && <p className="text-red-700">{error}</p>}
         </div>
       </div>

src/components/Authenticator/authenticator.ts

@@ -48,6 +48,7 @@ function handleGuest() {
     '/team/members',
     '/team/member',
     '/team/settings',
+    '/dashboard',
   ];
 
   showHideAuthElements('hide');

src/components/Badge.tsx

@@ -0,0 +1,27 @@
+type BadgeProps = {
+  variant: 'blue' | 'green' | 'red' | 'yellow' | 'grey' | 'white';
+  text: string;
+};
+
+export function Badge(type: BadgeProps) {
+  const { variant, text } = type;
+
+  const colors = {
+    blue: 'bg-blue-100 text-blue-700 border-blue-200',
+    green: 'bg-green-100 text-green-700 border-green-200',
+    red: 'bg-red-100 text-red-700 border-red-200',
+    yellow: 'bg-yellow-100 text-yellow-700 border-yellow-200',
+    grey: 'bg-gray-100 text-gray-700 border-gray-200',
+    white: 'bg-white text-black border-gray-200',
+    teal: 'bg-teal-100 text-teal-700 border-teal-200',
+    black: 'bg-gray-500 text-white border-gray-500',
+  };
+
+  return (
+    <span
+      className={`rounded-md border capitalize ${colors[variant]} px-1 py-0.5 text-xs tracking-wide`}
+    >
+      {text}
+    </span>
+  );
+}

src/components/Changelog/ChangelogItem.astro

@@ -0,0 +1,45 @@
+---
+import { DateTime } from 'luxon';
+import type { ChangelogFileType } from '../../lib/changelog';
+import ChangelogImages from '../ChangelogImages';
+
+interface Props {
+  changelog: ChangelogFileType;
+}
+
+const { changelog } = Astro.props;
+const { frontmatter } = changelog;
+
+const formattedDate = DateTime.fromISO(frontmatter.date).toFormat(
+  'dd LLL, yyyy',
+);
+---
+
+<div class='relative mb-6' id={changelog.id}>
+  <span
+    class='absolute -left-6 top-2 h-2 w-2 flex-shrink-0 rounded-full bg-gray-300'
+  ></span>
+
+  <div class='mb-3 flex flex-col sm:flex-row items-start sm:items-center gap-0.5 sm:gap-2'>
+    <span class='flex-shrink-0 text-xs tracking-wide text-gray-400'>
+      {formattedDate}
+    </span>
+    <span class='truncate text-base font-medium text-balance'>
+      {changelog.frontmatter.title}
+    </span>
+  </div>
+
+  <div class='rounded-xl border bg-white p-6'>
+    {frontmatter.images && (
+      <div class='mb-5 hidden sm:block -mx-6'>
+        <ChangelogImages images={frontmatter.images} client:load />
+      </div>
+    )}
+
+    <div
+      class='prose prose-sm prose-h2:mt-3 prose-h2:text-lg prose-h2:font-medium prose-p:mb-0 prose-blockquote:font-normal prose-blockquote:text-gray-500 prose-ul:my-0 prose-ul:rounded-lg prose-ul:bg-gray-100 prose-ul:px-4 prose-ul:py-4 prose-ul:pl-7 prose-img:mt-0 prose-img:rounded-lg [&>blockquote>p]:mt-0 [&>ul>li]:my-0 [&>ul>li]:mb-1 [&>ul]:mt-3'
+    >
+      <changelog.Content />
+    </div>
+  </div>
+</div>

src/components/Changelog/ChangelogLaunch.astro

@@ -0,0 +1,33 @@
+---
+import { DateTime } from 'luxon';
+
+const formattedDate = DateTime.fromISO('2024-09-13').toFormat('dd LLL, yyyy');
+---
+
+<div class='relative mb-6'>
+  <span
+    class='absolute -left-6 top-2 h-2 w-2 flex-shrink-0 rounded-full bg-gray-300'
+  ></span>
+
+  <div
+    class='mb-3 flex flex-col items-start gap-0.5 sm:flex-row sm:items-center sm:gap-2'
+  >
+    <span class='flex-shrink-0 text-xs tracking-wide text-gray-400'>
+      {formattedDate}
+    </span>
+    <span class='truncate text-balance text-base font-medium'>
+      Changelog page is launched
+    </span>
+  </div>
+
+  <div
+    class='flex flex-col items-center justify-center gap-2 sm:gap-2 rounded-xl border bg-white px-8 py-12 text-center'
+  >
+    <img src='/images/gifs/rocket.gif' class='w-[70px] mb-4' />
+    <h2 class='text-balance text-xl font-medium'>Changelog page is launched</h2>
+    <p class='font-normal text-balance text-gray-400 text-sm sm:text-base'>
+      We will be sharing a selected list of updates, improvements, and fixes made to
+      the website. Stay tuned!
+    </p>
+  </div>
+</div>

src/components/ChangelogBanner.astro

@@ -0,0 +1,64 @@
+---
+import { getAllChangelogs } from '../lib/changelog';
+import { DateTime } from 'luxon';
+
+const allChangelogs = await getAllChangelogs();
+const top10Changelogs = allChangelogs.slice(0, 10);
+---
+
+<div class='border-t bg-white py-6 text-left sm:py-16 sm:text-center'>
+  <div class='container !max-w-[650px]'>
+    <p class='text-2xl font-bold sm:text-5xl'>
+      <img
+        src='/images/gifs/rocket.gif'
+        alt='Rocket'
+        class='mr-2 hidden sm:inline h-12 w-12'
+      />
+      Actively Maintained
+    </p>
+    <p class='mt-1 mb-2 sm:my-2 text-sm leading-relaxed text-gray-600 sm:my-5 sm:text-lg'>
+      We are always improving our content, adding new resources and adding
+      features to enhance your learning experience.
+    </p>
+
+    <div class='relative mt-2 sm:mt-8 text-left'>
+      <div
+        class='absolute inset-y-0 left-[120px] hidden w-px -translate-x-[0.5px] translate-x-[5.75px] bg-gray-300 sm:block'
+      >
+      </div>
+      <ul class='relative flex flex-col gap-4 py-4'>
+        {
+          top10Changelogs.map((changelog) => {
+            const formattedDate = DateTime.fromISO(
+              changelog.frontmatter.date,
+            ).toFormat('dd LLL, yyyy');
+            return (
+              <li class='relative'>
+                <a
+                  href={`/changelog#${changelog.id}`}
+                  class='flex flex-col sm:flex-row items-start sm:items-center'
+                >
+                  <span class='sm:w-[120px] flex-shrink-0 pr-0 sm:pr-4 text-right text-sm tracking-wide text-gray-400'>
+                    {formattedDate}
+                  </span>
+                  <span class='h-3 w-3 flex-shrink-0 rounded-full bg-gray-300 hidden sm:block' />
+                  <span class='text-balance sm:pl-8 text-base font-medium text-gray-900'>
+                    {changelog.frontmatter.title}
+                  </span>
+                </a>
+              </li>
+            );
+          })
+        }
+      </ul>
+    </div>
+    <div class='mt-2 sm:mt-8 text-left sm:text-center'>
+      <a
+        href='/changelog'
+        class='inline-block text-sm sm:text-base rounded-lg sm:rounded-full bg-gray-800 px-4 sm:px-6 py-2 text-white transition-colors hover:bg-gray-700'
+      >
+        View Full Changelog
+      </a>
+    </div>
+  </div>
+</div>

src/components/ChangelogImages.tsx

@@ -0,0 +1,108 @@
+import { ChevronLeft, ChevronRight, MoveRight } from 'lucide-react';
+import React, { useState, useEffect, useCallback } from 'react';
+
+interface ChangelogImagesProps {
+  images: { [key: string]: string };
+}
+
+const ChangelogImages: React.FC<ChangelogImagesProps> = ({ images }) => {
+  const [enlargedImage, setEnlargedImage] = useState<string | null>(null);
+  const imageArray = Object.entries(images);
+
+  const handleImageClick = (src: string) => {
+    setEnlargedImage(src);
+  };
+
+  const handleCloseEnlarged = () => {
+    setEnlargedImage(null);
+  };
+
+  const handleNavigation = useCallback(
+    (direction: 'prev' | 'next') => {
+      if (!enlargedImage) return;
+      const currentIndex = imageArray.findIndex(
+        ([_, src]) => src === enlargedImage,
+      );
+      let newIndex;
+      if (direction === 'prev') {
+        newIndex = currentIndex > 0 ? currentIndex - 1 : imageArray.length - 1;
+      } else {
+        newIndex = currentIndex < imageArray.length - 1 ? currentIndex + 1 : 0;
+      }
+      setEnlargedImage(imageArray[newIndex][1]);
+    },
+    [enlargedImage, imageArray],
+  );
+
+  useEffect(() => {
+    const handleKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        handleCloseEnlarged();
+      } else if (event.key === 'ArrowLeft') {
+        handleNavigation('prev');
+      } else if (event.key === 'ArrowRight') {
+        handleNavigation('next');
+      }
+    };
+
+    window.addEventListener('keydown', handleKeyDown);
+    return () => window.removeEventListener('keydown', handleKeyDown);
+  }, [handleNavigation]);
+
+  return (
+    <>
+      <div className="flex gap-3 px-6 pb-1">
+        {imageArray.map(([title, src]) => (
+          <div
+            key={title}
+            className="group relative cursor-pointer overflow-hidden rounded-lg transition hover:scale-105"
+            onClick={() => handleImageClick(src)}
+          >
+            <img
+              src={src}
+              alt={title}
+              className="h-[120px] w-full object-cover object-left-top"
+            />
+            <span className="absolute group-hover:opacity-0 inset-0 bg-gradient-to-b from-transparent to-black/40" />
+
+            <div className="absolute font-medium inset-x-0 top-full group-hover:inset-y-0 flex items-center justify-center px-2 text-center text-xs bg-black/50 text-white py-0.5 opacity-0 group-hover:opacity-100 cursor-pointer">
+              <span className='bg-black py-0.5 rounded px-1'>{title}</span>
+            </div>
+          </div>
+        ))}
+      </div>
+      {enlargedImage && (
+        <div
+          className="fixed inset-0 z-[999] flex items-center justify-center bg-black bg-opacity-75"
+          onClick={handleCloseEnlarged}
+        >
+          <img
+            src={enlargedImage}
+            alt="Enlarged view"
+            className="max-h-[90%] max-w-[90%] rounded-xl object-contain"
+          />
+          <button
+            className="absolute left-4 top-1/2 -translate-y-1/2 transform rounded-full bg-white hover:bg-opacity-100 bg-opacity-50 p-2"
+            onClick={(e) => {
+              e.stopPropagation();
+              handleNavigation('prev');
+            }}
+          >
+            <ChevronLeft size={24} />
+          </button>
+          <button
+            className="absolute right-4 top-1/2 -translate-y-1/2 transform rounded-full bg-white hover:bg-opacity-100 bg-opacity-50 p-2"
+            onClick={(e) => {
+              e.stopPropagation();
+              handleNavigation('next');
+            }}
+          >
+            <ChevronRight size={24} />
+          </button>
+        </div>
+      )}
+    </>
+  );
+};
+
+export default ChangelogImages;

src/components/CommandMenu/CommandMenu.tsx

@@ -243,7 +243,7 @@ export function CommandMenu() {
                 const groupChanged = prevPage && prevPage.group !== page.group;
 
                 return (
-                  <Fragment key={page.id}>
+                  <Fragment key={page.group+'/'+page.id}>
                     {groupChanged && (
                       <div className="border-b border-gray-100"></div>
                     )}

src/components/CreateTeam/ContentConfirmationModal.tsx

@@ -0,0 +1,42 @@
+import { Modal } from '../Modal';
+
+type ContentConfirmationModalProps = {
+  onClose: () => void;
+  onClick: (shouldCopy: boolean) => void;
+};
+
+export function ContentConfirmationModal(props: ContentConfirmationModalProps) {
+  const { onClose, onClick } = props;
+
+  return (
+    <Modal onClose={onClose} wrapperClassName="max-w-lg">
+      <div className="p-4">
+        <h2 className="text-lg font-semibold">
+          Copy Node Details and Resources?
+        </h2>
+        <p className="balanc text-gray-600">
+          This will just copy the roadmap in your team. Would you like to copy
+          the resource links and node details as well?
+        </p>
+        <div className="mt-4 grid grid-cols-2 gap-2">
+          <button
+            className="rounded-lg border p-2.5 font-normal"
+            onClick={() => {
+              onClick(false);
+            }}
+          >
+            No, copy roadmap only
+          </button>
+          <button
+            className="rounded-lg border bg-black p-2.5 font-normal text-white hover:opacity-80"
+            onClick={() => {
+              onClick(true);
+            }}
+          >
+            Yes, also copy resources
+          </button>
+        </div>
+      </div>
+    </Modal>
+  );
+}

src/components/CreateTeam/RoadmapSelector.tsx

@@ -167,7 +167,7 @@ export function RoadmapSelector(props: RoadmapSelectorProps) {
         <SelectRoadmapModal
           onClose={() => setShowSelectRoadmapModal(false)}
           teamResourceConfig={teamResources}
-          allRoadmaps={allRoadmaps}
+          allRoadmaps={allRoadmaps.filter(r => r.renderer === 'editor')}
           teamId={teamId}
           onRoadmapAdd={(roadmapId) => {
             addTeamResource(roadmapId).finally(() => {

src/components/CreateTeam/SelectRoadmapModal.tsx

@@ -60,11 +60,11 @@ export function SelectRoadmapModal(props: SelectRoadmapModalProps) {
     setSearchResults(searchResults);
   }, [searchText, allRoadmaps]);
 
-  const roleBasedRoadmaps = searchResults.filter(
-    (roadmap) => roadmap?.metadata?.tags?.includes('role-roadmap'),
+  const roleBasedRoadmaps = searchResults.filter((roadmap) =>
+    roadmap?.metadata?.tags?.includes('role-roadmap'),
   );
-  const skillBasedRoadmaps = searchResults.filter(
-    (roadmap) => roadmap?.metadata?.tags?.includes('skill-roadmap'),
+  const skillBasedRoadmaps = searchResults.filter((roadmap) =>
+    roadmap?.metadata?.tags?.includes('skill-roadmap'),
   );
 
   return (
@@ -147,6 +147,15 @@ export function SelectRoadmapModal(props: SelectRoadmapModalProps) {
               })}
             </div>
           </div>
+
+          <div className="border-t border-t-yellow-300 text-yellow-900 bg-yellow-100 px-4 py-3 text-sm">
+            <h2 className='font-medium text-base text-yellow-900 mb-1'>More Official Roadmaps Coming Soon</h2>
+            <p>
+              We are currently adding more of our official
+              roadmaps to this list. If you don't see the roadmap you are
+              looking for, please check back later.
+            </p>
+          </div>
         </div>
       </div>
     </div>

src/components/CustomRoadmap/CreateRoadmap/CreateRoadmapModal.tsx

@@ -23,24 +23,44 @@ export const allowedCustomRoadmapType = ['role', 'skill'] as const;
 export type AllowedCustomRoadmapType =
   (typeof allowedCustomRoadmapType)[number];
 
+export const allowedShowcaseStatus = ['visible', 'hidden'] as const;
+export type AllowedShowcaseStatus = (typeof allowedShowcaseStatus)[number];
+
 export interface RoadmapDocument {
   _id?: string;
   title: string;
   description?: string;
   slug?: string;
   creatorId: string;
+  aiRoadmapId?: string;
   teamId?: string;
-  isDiscoverable: boolean;
-  type: AllowedCustomRoadmapType;
+  topicCount: number;
   visibility: AllowedRoadmapVisibility;
   sharedFriendIds?: string[];
   sharedTeamMemberIds?: string[];
+  feedbacks?: {
+    userId: string;
+    email: string;
+    feedback: string;
+  }[];
+  metadata?: {
+    originalRoadmapId?: string;
+    defaultRoadmapId?: string;
+  };
   nodes: any[];
   edges: any[];
+
+  isDiscoverable?: boolean;
+  showcaseStatus?: AllowedShowcaseStatus;
+  ratings: {
+    average: number;
+    breakdown: {
+      [key: number]: number;
+    };
+  };
+
   createdAt: Date;
   updatedAt: Date;
-  canManage: boolean;
-  isCustomResource: boolean;
 }
 
 interface CreateRoadmapModalProps {