diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b0f626e..e924b1e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,7 +10,7 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  GO_VERSION: '1.24.3'
+  GO_VERSION: '1.24.4'
   TEMPL_VERSION: 'v0.3.898'
 
 jobs:
@@ -169,7 +169,7 @@ jobs:
     
     strategy:
       matrix:
-        go-version: ['1.24.3'] # Removed 1.23 to reduce costs and complexity
+        go-version: ['1.24.4'] # Removed 1.23 to reduce costs and complexity
       fail-fast: false
 
     steps:
diff --git a/Dockerfile b/Dockerfile
index f37a79e..228ad58 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -18,7 +18,7 @@ COPY internal/ ./internal/
 RUN npx tailwindcss -i ./public/css/style.css -o ./public/css/site.css --minify
 
 # ===== Go Build Stage =====
-FROM golang:1.24-alpine AS go-builder
+FROM golang:1.24.4-alpine AS go-builder
 
 # Install templ CLI
 RUN go install github.com/a-h/templ/cmd/templ@v0.3.898
diff --git a/go.mod b/go.mod
index fa123df..52b7393 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module github.com/jgndev/jgn.dev
 
-go 1.24.3
+go 1.24.4
 
 require (
 	github.com/a-h/templ v0.3.898
diff --git a/internal/application/webhook.go b/internal/application/webhook.go
index c6a35ad..3043648 100644
--- a/internal/application/webhook.go
+++ b/internal/application/webhook.go
@@ -11,6 +11,7 @@ import (
 	"os"
 	"strings"
 
+	"github.com/jgndev/jgn.dev/internal/site"
 	"github.com/labstack/echo/v4"
 )
 
@@ -96,18 +97,64 @@ func (app *Application) WebhookHandler(c echo.Context) error {
 		})
 	}
 
-	// Refresh content from GitHub
-	log.Printf("Refreshing content due to webhook from %s", payload.Repository.FullName)
-	if err := app.ContentManager.RefreshContent(); err != nil {
-		log.Printf("Failed to refresh content: %v", err)
+	// Determine which content manager to refresh based on repository
+	repoName := payload.Repository.Name
+	log.Printf("Refreshing content due to webhook from %s (repo: %s)", payload.Repository.FullName, repoName)
+	
+	// Import site package to access repository names
+	var refreshErr error
+	refreshed := false
+	
+	// Check if this is the posts repository
+	if repoName == site.PostRepoName {
+		log.Printf("Detected posts repository, refreshing ContentManager")
+		refreshErr = app.ContentManager.RefreshContent()
+		refreshed = true
+	}
+	
+	// Check if this is the cheatsheets repository
+	if repoName == site.CheatsheetRepoName {
+		log.Printf("Detected cheatsheets repository, refreshing CheatsheetManager")
+		refreshErr = app.CheatsheetManager.RefreshContent()
+		refreshed = true
+	}
+	
+	// If repository wasn't recognized, refresh both managers as fallback
+	if !refreshed {
+		log.Printf("WARNING: Unknown repository '%s', refreshing both managers as fallback", repoName)
+		
+		// Try to refresh posts first
+		if err := app.ContentManager.RefreshContent(); err != nil {
+			log.Printf("Failed to refresh posts during fallback: %v", err)
+			refreshErr = err
+		} else {
+			log.Printf("Successfully refreshed posts during fallback")
+		}
+		
+		// Try to refresh cheatsheets
+		if err := app.CheatsheetManager.RefreshContent(); err != nil {
+			log.Printf("Failed to refresh cheatsheets during fallback: %v", err)
+			if refreshErr == nil {
+				refreshErr = err
+			}
+		} else {
+			log.Printf("Successfully refreshed cheatsheets during fallback")
+		}
+	}
+	
+	// Handle refresh errors
+	if refreshErr != nil {
+		log.Printf("Failed to refresh content for repository %s: %v", repoName, refreshErr)
 		return c.JSON(http.StatusInternalServerError, map[string]string{
 			"error": "failed to refresh content",
+			"repository": repoName,
 		})
 	}
 
-	log.Printf("Successfully refreshed content from webhook")
+	log.Printf("Successfully refreshed content from webhook for repository: %s", repoName)
 	return c.JSON(http.StatusOK, map[string]string{
 		"message": "content refreshed successfully",
+		"repository": repoName,
 	})
 }
 
diff --git a/internal/contentmanager/cheatsheetmanager.go b/internal/contentmanager/cheatsheetmanager.go
index e1cd510..497fe70 100644
--- a/internal/contentmanager/cheatsheetmanager.go
+++ b/internal/contentmanager/cheatsheetmanager.go
@@ -10,6 +10,7 @@ import (
 	"sort"
 	"strings"
 	"sync"
+	"time"
 )
 
 // CheatsheetManager manages the retrieval, storage, and filtering of cheatsheets from a remote GitHub repository.
@@ -41,95 +42,107 @@ func NewCheatsheetManager(repoOwner, repoName string) *CheatsheetManager {
 // listRepoContent retrieves the content of a GitHub repository at a specified path using the GitHub API.
 // It handles both directory listings and single file retrieval, returning a slice of githubContent or an error.
 func (cm *CheatsheetManager) listRepoContent(path string) ([]githubContent, error) {
-	url := fmt.Sprintf("https://api.github.com/repos/%s/%s/contents/%s", cm.repoOwner, cm.repoName, path)
-
-	log.Printf("fetching cheatsheet content from: %s", url)
-
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, err
-	}
+	var contents []githubContent
+	
+	err := retryWithBackoff(func() error {
+		url := fmt.Sprintf("https://api.github.com/repos/%s/%s/contents/%s", cm.repoOwner, cm.repoName, path)
 
-	req.Header.Set("Accept", "application/vnd.github.v3+json")
+		log.Printf("fetching cheatsheet content from: %s", url)
 
-	// Add authentication if a token is available
-	if cm.githubToken != "" {
-		req.Header.Set("Authorization", "token "+cm.githubToken)
-	}
+		req, err := http.NewRequest("GET", url, nil)
+		if err != nil {
+			return err
+		}
 
-	resp, err := cm.client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
+		req.Header.Set("Accept", "application/vnd.github.v3+json")
 
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("GitHub API returned status %d", resp.StatusCode)
-	}
+		// Add authentication if a token is available
+		if cm.githubToken != "" {
+			req.Header.Set("Authorization", "token "+cm.githubToken)
+		}
 
-	// Try to decode as an array first (directory listing)
-	var contents []githubContent
-	if err := json.NewDecoder(resp.Body).Decode(&contents); err != nil {
-		// If that fails, it might be a single file
-		resp.Body.Close()
-		resp, err = cm.client.Do(req)
+		resp, err := cm.client.Do(req)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		defer resp.Body.Close()
 
-		var singleContent githubContent
-		if err := json.NewDecoder(resp.Body).Decode(&singleContent); err != nil {
-			return nil, fmt.Errorf("failed to decode response as array or single file: %v", err)
+		if resp.StatusCode != http.StatusOK {
+			return fmt.Errorf("GitHub API returned status %d", resp.StatusCode)
 		}
-		return []githubContent{singleContent}, nil
-	}
 
-	return contents, nil
+		// Try to decode as an array first (directory listing)
+		if err := json.NewDecoder(resp.Body).Decode(&contents); err != nil {
+			// If that fails, it might be a single file
+			resp.Body.Close()
+			resp, err = cm.client.Do(req)
+			if err != nil {
+				return err
+			}
+			defer resp.Body.Close()
+
+			var singleContent githubContent
+			if err := json.NewDecoder(resp.Body).Decode(&singleContent); err != nil {
+				return fmt.Errorf("failed to decode response as array or single file: %v", err)
+			}
+			contents = []githubContent{singleContent}
+		}
+		
+		return nil
+	}, 3, time.Second)
+	
+	return contents, err
 }
 
 // fetchFileContent retrieves the content of a file from a GitHub repository using the GitHub API.
 // It decodes the content if it is encoded in base64 and returns it as a string. Returns an error if the operation fails.
 func (cm *CheatsheetManager) fetchFileContent(path string) (string, error) {
-	url := fmt.Sprintf("https://api.github.com/repos/%s/%s/contents/%s", cm.repoOwner, cm.repoName, path)
-
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return "", err
-	}
-
-	req.Header.Set("Accept", "application/vnd.github.v3+json")
-
-	// Add authentication if a token is available
-	if cm.githubToken != "" {
-		req.Header.Set("Authorization", "token "+cm.githubToken)
-	}
+	var content string
+	
+	err := retryWithBackoff(func() error {
+		url := fmt.Sprintf("https://api.github.com/repos/%s/%s/contents/%s", cm.repoOwner, cm.repoName, path)
 
-	resp, err := cm.client.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
+		req, err := http.NewRequest("GET", url, nil)
+		if err != nil {
+			return err
+		}
 
-	var result struct {
-		Content  string `json:"content"`
-		Encoding string `json:"encoding"`
-	}
+		req.Header.Set("Accept", "application/vnd.github.v3+json")
 
-	if err = json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		return "", err
-	}
+		// Add authentication if a token is available
+		if cm.githubToken != "" {
+			req.Header.Set("Authorization", "token "+cm.githubToken)
+		}
 
-	if result.Encoding == "base64" {
-		content, err := base64.StdEncoding.DecodeString(result.Content)
+		resp, err := cm.client.Do(req)
 		if err != nil {
-			return "", err
+			return err
 		}
+		defer resp.Body.Close()
 
-		return string(content), nil
-	}
+		var result struct {
+			Content  string `json:"content"`
+			Encoding string `json:"encoding"`
+		}
 
-	return result.Content, nil
+		if err = json.NewDecoder(resp.Body).Decode(&result); err != nil {
+			return err
+		}
+
+		if result.Encoding == "base64" {
+			decoded, err := base64.StdEncoding.DecodeString(result.Content)
+			if err != nil {
+				return err
+			}
+			content = string(decoded)
+		} else {
+			content = result.Content
+		}
+		
+		return nil
+	}, 3, time.Second)
+	
+	return content, err
 }
 
 // matchesAllTermsCheatsheet checks if all the provided search terms are present in a Cheatsheet's combined text fields.
diff --git a/internal/contentmanager/contentmanager.go b/internal/contentmanager/contentmanager.go
index 961594a..8bd7138 100644
--- a/internal/contentmanager/contentmanager.go
+++ b/internal/contentmanager/contentmanager.go
@@ -10,8 +10,28 @@ import (
 	"sort"
 	"strings"
 	"sync"
+	"time"
 )
 
+// retryWithBackoff executes a function with exponential backoff retry logic
+func retryWithBackoff(fn func() error, maxRetries int, baseDelay time.Duration) error {
+	var lastErr error
+	for attempt := 0; attempt <= maxRetries; attempt++ {
+		if err := fn(); err != nil {
+			lastErr = err
+			if attempt < maxRetries {
+				delay := baseDelay * time.Duration(1<<attempt) // exponential backoff: 1s, 2s, 4s
+				log.Printf("Attempt %d failed, retrying in %v: %v", attempt+1, delay, err)
+				time.Sleep(delay)
+				continue
+			}
+		} else {
+			return nil // success
+		}
+	}
+	return lastErr
+}
+
 // ContentManager manages content storage and operations, providing synchronization and interaction with GitHub repositories.
 type ContentManager struct {
 	sync.RWMutex
@@ -42,95 +62,107 @@ func NewContentManager(repoOwner, repoName string) *ContentManager {
 // listRepoContent retrieves the content of a GitHub repository for the provided path.
 // It supports retrieving directories or single files and returns an array of githubContent items.
 func (cm *ContentManager) listRepoContent(path string) ([]githubContent, error) {
-	url := fmt.Sprintf("https://api.github.com/repos/%s/%s/contents/%s", cm.repoOwner, cm.repoName, path)
-
-	log.Printf("fetching content from: %s", url)
-
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return nil, err
-	}
+	var contents []githubContent
+	
+	err := retryWithBackoff(func() error {
+		url := fmt.Sprintf("https://api.github.com/repos/%s/%s/contents/%s", cm.repoOwner, cm.repoName, path)
 
-	req.Header.Set("Accept", "application/vnd.github.v3+json")
+		log.Printf("fetching content from: %s", url)
 
-	// Add authentication if a token is available
-	if cm.githubToken != "" {
-		req.Header.Set("Authorization", "token "+cm.githubToken)
-	}
+		req, err := http.NewRequest("GET", url, nil)
+		if err != nil {
+			return err
+		}
 
-	resp, err := cm.client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
+		req.Header.Set("Accept", "application/vnd.github.v3+json")
 
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("GitHub API returned status %d", resp.StatusCode)
-	}
+		// Add authentication if a token is available
+		if cm.githubToken != "" {
+			req.Header.Set("Authorization", "token "+cm.githubToken)
+		}
 
-	// Try to decode as an array first (directory listing)
-	var contents []githubContent
-	if err := json.NewDecoder(resp.Body).Decode(&contents); err != nil {
-		// If that fails, it might be a single file
-		resp.Body.Close()
-		resp, err = cm.client.Do(req)
+		resp, err := cm.client.Do(req)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		defer resp.Body.Close()
 
-		var singleContent githubContent
-		if err := json.NewDecoder(resp.Body).Decode(&singleContent); err != nil {
-			return nil, fmt.Errorf("failed to decode response as array or single file: %v", err)
+		if resp.StatusCode != http.StatusOK {
+			return fmt.Errorf("GitHub API returned status %d", resp.StatusCode)
 		}
-		return []githubContent{singleContent}, nil
-	}
 
-	return contents, nil
+		// Try to decode as an array first (directory listing)
+		if err := json.NewDecoder(resp.Body).Decode(&contents); err != nil {
+			// If that fails, it might be a single file
+			resp.Body.Close()
+			resp, err = cm.client.Do(req)
+			if err != nil {
+				return err
+			}
+			defer resp.Body.Close()
+
+			var singleContent githubContent
+			if err := json.NewDecoder(resp.Body).Decode(&singleContent); err != nil {
+				return fmt.Errorf("failed to decode response as array or single file: %v", err)
+			}
+			contents = []githubContent{singleContent}
+		}
+		
+		return nil
+	}, 3, time.Second)
+	
+	return contents, err
 }
 
 // fetchFileContent retrieves the content of a file from a GitHub repository by its path.
 // It decodes base64-encoded content if necessary and returns the file content or an error.
 func (cm *ContentManager) fetchFileContent(path string) (string, error) {
-	url := fmt.Sprintf("https://api.github.com/repos/%s/%s/contents/%s", cm.repoOwner, cm.repoName, path)
-
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return "", err
-	}
-
-	req.Header.Set("Accept", "application/vnd.github.v3+json")
+	var content string
+	
+	err := retryWithBackoff(func() error {
+		url := fmt.Sprintf("https://api.github.com/repos/%s/%s/contents/%s", cm.repoOwner, cm.repoName, path)
 
-	// Add authentication if a token is available
-	if cm.githubToken != "" {
-		req.Header.Set("Authorization", "token "+cm.githubToken)
-	}
+		req, err := http.NewRequest("GET", url, nil)
+		if err != nil {
+			return err
+		}
 
-	resp, err := cm.client.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
+		req.Header.Set("Accept", "application/vnd.github.v3+json")
 
-	var result struct {
-		Content  string `json:"content"`
-		Encoding string `json:"encoding"`
-	}
-
-	if err = json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		return "", err
-	}
+		// Add authentication if a token is available
+		if cm.githubToken != "" {
+			req.Header.Set("Authorization", "token "+cm.githubToken)
+		}
 
-	if result.Encoding == "base64" {
-		content, err := base64.StdEncoding.DecodeString(result.Content)
+		resp, err := cm.client.Do(req)
 		if err != nil {
-			return "", err
+			return err
 		}
+		defer resp.Body.Close()
 
-		return string(content), nil
-	}
+		var result struct {
+			Content  string `json:"content"`
+			Encoding string `json:"encoding"`
+		}
+
+		if err = json.NewDecoder(resp.Body).Decode(&result); err != nil {
+			return err
+		}
 
-	return result.Content, nil
+		if result.Encoding == "base64" {
+			decoded, err := base64.StdEncoding.DecodeString(result.Content)
+			if err != nil {
+				return err
+			}
+			content = string(decoded)
+		} else {
+			content = result.Content
+		}
+		
+		return nil
+	}, 3, time.Second)
+	
+	return content, err
 }
 
 // matchesAllTerms checks if all terms in the given list exist in the combined searchable fields of the provided post.
diff --git a/scripts/test-webhook-enhanced.sh b/scripts/test-webhook-enhanced.sh
new file mode 100755
index 0000000..a07635e
--- /dev/null
+++ b/scripts/test-webhook-enhanced.sh
@@ -0,0 +1,91 @@
+#!/bin/bash
+
+# Enhanced test script for GitHub webhook endpoint
+# Tests both posts and cheatsheets repositories
+
+if [ -z "$GITHUB_WEBHOOK_SECRET" ]; then
+    echo "Error: GITHUB_WEBHOOK_SECRET environment variable must be set"
+    echo "Generate one with: openssl rand -hex 32"
+    exit 1
+fi
+
+WEBHOOK_URL="http://localhost:8080/webhook/github"
+
+# Test function
+test_webhook() {
+    local repo_name=$1
+    local repo_full_name=$2
+    local test_file=$3
+    
+    echo "========================================="
+    echo "Testing webhook for $repo_name repository"
+    echo "========================================="
+    
+    # Sample webhook payload
+    PAYLOAD='{
+  "ref": "refs/heads/main",
+  "commits": [
+    {
+      "added": ["'$test_file'"],
+      "modified": [],
+      "removed": []
+    }
+  ],
+  "repository": {
+    "name": "'$repo_name'",
+    "full_name": "'$repo_full_name'"
+  }
+}'
+
+    # Calculate HMAC signature
+    SIGNATURE=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "$GITHUB_WEBHOOK_SECRET" | cut -d' ' -f2)
+
+    echo "Repository: $repo_name"
+    echo "Test file: $test_file"
+    echo ""
+
+    # Send the webhook request
+    RESPONSE=$(curl -s -X POST "$WEBHOOK_URL" \
+      -H "Content-Type: application/json" \
+      -H "X-Hub-Signature-256: sha256=$SIGNATURE" \
+      -d "$PAYLOAD" \
+      -w "\nHTTP_STATUS:%{http_code}")
+
+    # Parse response
+    HTTP_STATUS=$(echo "$RESPONSE" | tail -n1 | cut -d: -f2)
+    BODY=$(echo "$RESPONSE" | head -n -1)
+
+    echo "HTTP Status: $HTTP_STATUS"
+    echo "Response: $BODY"
+    
+    if [ "$HTTP_STATUS" = "200" ]; then
+        echo "✅ Test PASSED for $repo_name repository"
+    else
+        echo "❌ Test FAILED for $repo_name repository"
+    fi
+    
+    echo ""
+    sleep 2
+}
+
+# Test posts repository
+test_webhook "posts" "jgndev/posts" "new-test-post.md"
+
+# Test cheatsheets repository  
+test_webhook "cheatsheets" "jgndev/cheatsheets" "new-test-cheatsheet.md"
+
+# Test unknown repository (should trigger fallback)
+test_webhook "unknown-repo" "jgndev/unknown-repo" "test-file.md"
+
+echo "========================================="
+echo "All webhook tests completed!"
+echo "========================================="
+echo "Check your server logs to verify:"
+echo "1. Posts repository triggered ContentManager refresh"
+echo "2. Cheatsheets repository triggered CheatsheetManager refresh"  
+echo "3. Unknown repository triggered fallback (both managers)"
+echo ""
+echo "Expected log messages:"
+echo "- 'Detected posts repository, refreshing ContentManager'"
+echo "- 'Detected cheatsheets repository, refreshing CheatsheetManager'"
+echo "- 'WARNING: Unknown repository 'unknown-repo', refreshing both managers as fallback'"
\ No newline at end of file
diff --git a/server/main.go b/server/main.go
index 5919c6b..2560b78 100644
--- a/server/main.go
+++ b/server/main.go
@@ -108,7 +108,9 @@
 package main
 
 import (
+	"log"
 	"net/http"
+	"os"
 	"strconv"
 	"strings"
 	"time"
@@ -177,7 +179,30 @@ func cacheMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
 	}
 }
 
+// validateEnvironment checks critical environment variables and logs warnings
+func validateEnvironment() {
+	githubToken := os.Getenv("GITHUB_TOKEN")
+	if githubToken == "" {
+		log.Println("WARNING: GITHUB_TOKEN not set - GitHub API requests will be rate limited (60/hour vs 5000/hour)")
+		log.Println("         This may cause webhook failures during high traffic periods")
+		log.Println("         Set GITHUB_TOKEN environment variable with a GitHub personal access token")
+	} else {
+		log.Println("✓ GITHUB_TOKEN configured - GitHub API rate limit: 5000/hour")
+	}
+	
+	webhookSecret := os.Getenv("GITHUB_WEBHOOK_SECRET")
+	if webhookSecret == "" {
+		log.Println("WARNING: GITHUB_WEBHOOK_SECRET not set - webhook endpoint will reject all requests")
+		log.Println("         Set GITHUB_WEBHOOK_SECRET environment variable to enable webhook functionality")
+	} else {
+		log.Println("✓ GITHUB_WEBHOOK_SECRET configured - webhook endpoint secured")
+	}
+}
+
 func main() {
+	// Validate critical environment variables
+	validateEnvironment()
+	
 	e := echo.New()
 
 	// Configure middleware
diff --git a/verify-webhook-fix.md b/verify-webhook-fix.md
new file mode 100644
index 0000000..85fac37
--- /dev/null
+++ b/verify-webhook-fix.md
@@ -0,0 +1,88 @@
+# Webhook Reliability Fix Verification
+
+## Changes Made
+
+### ✅ 1. Repository Detection
+- **File**: `/internal/application/webhook.go:99-143`
+- **Change**: Added logic to detect repository name from webhook payload
+- **Result**: Posts → `ContentManager.RefreshContent()`, Cheatsheets → `CheatsheetManager.RefreshContent()`
+
+### ✅ 2. Fallback Mechanism
+- **File**: `/internal/application/webhook.go:122-145`
+- **Change**: Added fallback to refresh both managers for unknown repositories
+- **Result**: Ensures content updates even if repository detection fails
+
+### ✅ 3. Retry Logic with Exponential Backoff
+- **Files**: 
+  - `/internal/contentmanager/contentmanager.go:16-32` (retry helper)
+  - `/internal/contentmanager/contentmanager.go:64-115` (listRepoContent)
+  - `/internal/contentmanager/contentmanager.go:119-166` (fetchFileContent)
+  - `/internal/contentmanager/cheatsheetmanager.go:44-95` (listRepoContent)
+  - `/internal/contentmanager/cheatsheetmanager.go:99-146` (fetchFileContent)
+- **Change**: Added 3 retry attempts with 1s, 2s, 4s delays for GitHub API calls
+- **Result**: Handles transient GitHub API failures automatically
+
+### ✅ 4. Environment Variable Validation
+- **File**: `/server/main.go:182-200`
+- **Change**: Added startup validation for `GITHUB_TOKEN` and `GITHUB_WEBHOOK_SECRET`
+- **Result**: Clear warnings when environment variables are missing
+
+### ✅ 5. Enhanced Error Logging
+- **File**: `/internal/application/webhook.go` (throughout)
+- **Change**: Added repository context to all log messages and errors
+- **Result**: Better debugging and monitoring capabilities
+
+### ✅ 6. Enhanced Testing
+- **File**: `/scripts/test-webhook-enhanced.sh`
+- **Change**: Created comprehensive test script for both repositories
+- **Result**: Easy testing of posts, cheatsheets, and fallback scenarios
+
+## Testing Instructions
+
+1. **Set environment variables**:
+   ```bash
+   export GITHUB_WEBHOOK_SECRET=$(openssl rand -hex 32)
+   export GITHUB_TOKEN=your_github_token_here
+   ```
+
+2. **Start the server**:
+   ```bash
+   go run ./server/main.go
+   ```
+
+3. **Run webhook tests**:
+   ```bash
+   ./scripts/test-webhook-enhanced.sh
+   ```
+
+4. **Verify logs show**:
+   - ✓ Environment variable validation messages
+   - ✓ Repository-specific refresh messages
+   - ✓ Retry attempts for any API failures
+
+## Before vs After
+
+**Before**: 
+- ❌ Only posts repository worked
+- ❌ No retry on GitHub API failures  
+- ❌ No environment validation
+- ❌ Limited error context
+
+**After**:
+- ✅ Both posts and cheatsheets repositories work
+- ✅ Automatic retry with exponential backoff
+- ✅ Startup environment validation with clear warnings
+- ✅ Comprehensive error logging with repository context
+- ✅ Fallback mechanism for unknown repositories
+
+## Key Fix Summary
+
+The **critical issue** was that the webhook only called `app.ContentManager.RefreshContent()` regardless of which repository triggered it. Now it:
+
+1. **Detects repository** from webhook payload
+2. **Calls appropriate manager** (ContentManager for posts, CheatsheetManager for cheatsheets)
+3. **Falls back to both** if repository is unknown
+4. **Retries API calls** if they fail
+5. **Logs everything** with proper context
+
+This ensures **cheatsheets will now update** when you push to the cheatsheets repository.
\ No newline at end of file