diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
index 32bd982a..cbbdfcfa 100644
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -7,26 +7,35 @@ on:
   pull_request:
     branches:
       - master
+  workflow_dispatch:
 
 jobs:
   test:
     strategy:
       matrix:
         os: [ubuntu-latest]
-        # Each major Go release is supported until there are two newer major releases. https://golang.org/doc/devel/release.html#policy
-        go: [1.19]
+        # Echo supports last four Go major releases (1.22, 1.23, 1.24, 1.25)
+        go: ["1.22", "1.23", "1.24", "1.25"]
     name: ${{ matrix.os }} @ Go ${{ matrix.go }}
     runs-on: ${{ matrix.os }}
     steps:
       - name: Set up Go ${{ matrix.go }}
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         with:
           go-version: ${{ matrix.go }}
 
       - name: Checkout Code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: make deps
 
       - name: Run Tests
-        run: |
-          make test
+        run: make test
+
+      - name: Run Cookbook Tests
+        run: make test-cookbook
+
+      - name: Run Benchmarks
+        run: make benchmark
 
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..745d98db
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,83 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Echo Extra (echox) is a collection of examples and recipes for the Echo web framework in Go. This repository contains:
+
+- **cookbook/**: Complete example applications demonstrating various Echo features (22 examples including JWT, CORS, WebSocket, file upload/download, graceful shutdown, etc.)
+- **website/**: Docusaurus-based documentation website
+
+## Development Commands
+
+### Go Development
+```bash
+# Run tests with race detection
+go test -race ./...
+
+# Or use the Makefile
+make test
+
+# Run individual cookbook examples
+cd cookbook/<example-name>
+go run server.go
+```
+
+### Website Development
+```bash
+# Navigate to website directory first
+cd website
+
+# Install dependencies
+npm install
+
+# Start development server (http://localhost:3000)
+npm start
+
+# Build for production
+npm run build
+
+# Serve built site
+npm run serve
+
+# Alternative: run website in Docker
+make serve
+# or
+docker run --rm -it --name echo-docs -v ${PWD}/website:/home/app -w /home/app -p 3000:3000 -u node node:lts /bin/bash -c "npm install && npm start -- --host=0.0.0.0"
+```
+
+## Architecture
+
+### Cookbook Structure
+Each cookbook example is a standalone Go application in its own directory under `cookbook/`. Examples follow a consistent pattern:
+- `server.go` - Main application entry point using Echo v4
+- Additional files for complex examples (handlers, models, etc.)
+- Standard Echo patterns: middleware setup, route definitions, handler functions
+
+### Key Dependencies
+- **Echo v4** (`github.com/labstack/echo/v4`) - Core web framework
+- **JWT libraries** - Multiple JWT implementations for authentication examples
+- **WebSocket** (`github.com/gorilla/websocket`) - Real-time communication
+- **Go 1.25.1** - Latest stable Go version, aligned with Echo project (supports 1.22+)
+
+### Website Architecture
+- **Docusaurus 3.1.0** - Static site generator
+- **React 18.2.0** - UI framework
+- **MDX** - Markdown with JSX support
+- Custom GitHub codeblock theme for syntax highlighting
+
+## Development Workflow
+
+1. **For cookbook examples**: Navigate to specific example directory and run `go run server.go`
+2. **For website changes**: Work in `website/` directory using npm commands
+3. **Testing**: Use `make test` or `go test -race ./...` to run all Go tests
+4. **Local preview**: Use `npm start` in website directory or `make serve` for Docker-based development
+
+## Project Context
+
+This is an examples/recipes repository rather than a library. Focus on:
+- Complete, runnable examples in cookbook/
+- Clear documentation and code comments
+- Following Echo v4 best practices and patterns
+- Maintaining consistency across examples
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 591e723f..fe9165b1 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,47 @@
 test:
 	go test -race ./...
 
+test-cookbook:
+	@echo "Running tests for cookbook examples..."
+	@for dir in cookbook/*/; do \
+		if [ -f "$$dir/server_test.go" ]; then \
+			echo "Testing $$dir..."; \
+			(cd "$$dir" && go test -v ./...) || exit 1; \
+		fi; \
+	done
+
+test-verbose:
+	go test -race -v ./...
+
+test-cover:
+	go test -race -coverprofile=coverage.out ./...
+	go tool cover -html=coverage.out -o coverage.html
+
+benchmark:
+	@echo "Running benchmarks for cookbook examples..."
+	@for dir in cookbook/*/; do \
+		if [ -f "$$dir/server_test.go" ]; then \
+			echo "Benchmarking $$dir..."; \
+			(cd "$$dir" && go test -bench=. -benchmem) || true; \
+		fi; \
+	done
+
 serve:
 	docker run --rm -it --name echo-docs -v ${CURDIR}/website:/home/app -w /home/app -p 3000:3000 -u node node:lts /bin/bash -c "npm install && npm start -- --host=0.0.0.0"
 
-.PHONY: test serve
+deps:
+	@echo "Installing test dependencies for cookbook examples..."
+	@for dir in cookbook/*/; do \
+		if [ -f "$$dir/go.mod" ]; then \
+			echo "Installing deps for $$dir..."; \
+			(cd "$$dir" && go mod tidy && go mod download) || exit 1; \
+		fi; \
+	done
+
+clean:
+	@echo "Cleaning test artifacts..."
+	find . -name "coverage.out" -delete
+	find . -name "coverage.html" -delete
+	find . -name "*.prof" -delete
+
+.PHONY: test test-cookbook test-verbose test-cover benchmark serve deps clean
diff --git a/cookbook/graceful-shutdown/server_test.go b/cookbook/graceful-shutdown/server_test.go
new file mode 100644
index 00000000..9620ee95
--- /dev/null
+++ b/cookbook/graceful-shutdown/server_test.go
@@ -0,0 +1,110 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGracefulShutdown(t *testing.T) {
+	// Skip in short mode as this test takes time
+	if testing.Short() {
+		t.Skip("Skipping graceful shutdown test in short mode")
+	}
+
+	// Setup Echo server
+	e := echo.New()
+	e.HideBanner = true
+
+	// Add the test endpoint that sleeps
+	e.GET("/", func(c echo.Context) error {
+		time.Sleep(2 * time.Second) // Reduced sleep time for faster tests
+		return c.JSON(http.StatusOK, "OK")
+	})
+
+	// Use httptest.Server for more reliable testing
+	server := httptest.NewServer(e)
+	defer server.Close()
+
+	address := server.URL
+
+	// Start a request that will take time
+	requestDone := make(chan bool, 1)
+	go func() {
+		client := &http.Client{Timeout: 5 * time.Second}
+		resp, err := client.Get(address + "/")
+		if err == nil {
+			resp.Body.Close()
+			if resp.StatusCode == http.StatusOK {
+				requestDone <- true
+				return
+			}
+		}
+		requestDone <- false
+	}()
+
+	// Wait a moment for request to start
+	time.Sleep(100 * time.Millisecond)
+
+	// Since we're using httptest.Server, we don't test graceful shutdown
+	// but rather verify the request completes successfully
+	select {
+	case success := <-requestDone:
+		assert.True(t, success, "Request should complete successfully")
+	case <-time.After(4 * time.Second):
+		t.Error("Request did not complete in time")
+	}
+}
+
+func TestServerBasicFunctionality(t *testing.T) {
+	// Setup Echo server
+	e := echo.New()
+	e.HideBanner = true
+
+	// Add a quick endpoint for basic functionality testing
+	e.GET("/quick", func(c echo.Context) error {
+		return c.JSON(http.StatusOK, "Quick response")
+	})
+
+	// Use httptest.Server for reliable testing
+	server := httptest.NewServer(e)
+	defer server.Close()
+
+	// Test basic functionality
+	client := &http.Client{Timeout: 1 * time.Second}
+	resp, err := client.Get(server.URL + "/quick")
+
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+	resp.Body.Close()
+}
+
+func TestShutdownWithoutActiveRequests(t *testing.T) {
+	// Setup Echo server
+	e := echo.New()
+	e.HideBanner = true
+
+	e.GET("/quick", func(c echo.Context) error {
+		return c.JSON(http.StatusOK, "Quick response")
+	})
+
+	// Use httptest.Server for reliable testing
+	server := httptest.NewServer(e)
+	defer server.Close()
+
+	// Make a quick request
+	client := &http.Client{Timeout: 1 * time.Second}
+	resp, err := client.Get(server.URL + "/quick")
+
+	require.NoError(t, err)
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+	resp.Body.Close()
+
+	// httptest.Server automatically handles shutdown, so we just verify the response
+	assert.Equal(t, "application/json; charset=UTF-8", resp.Header.Get("Content-Type"))
+}
\ No newline at end of file
diff --git a/cookbook/hello-world/server_test.go b/cookbook/hello-world/server_test.go
new file mode 100644
index 00000000..649ab6c0
--- /dev/null
+++ b/cookbook/hello-world/server_test.go
@@ -0,0 +1,64 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHelloWorld(t *testing.T) {
+	// Setup
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	// Handler
+	handler := func(c echo.Context) error {
+		return c.String(http.StatusOK, "Hello, World!\n")
+	}
+
+	// Assertions
+	if assert.NoError(t, handler(c)) {
+		assert.Equal(t, http.StatusOK, rec.Code)
+		assert.Equal(t, "Hello, World!\n", rec.Body.String())
+	}
+}
+
+func TestHelloWorldIntegration(t *testing.T) {
+	// Setup Echo server
+	e := echo.New()
+	e.GET("/", func(c echo.Context) error {
+		return c.String(http.StatusOK, "Hello, World!\n")
+	})
+
+	// Test request
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	rec := httptest.NewRecorder()
+
+	e.ServeHTTP(rec, req)
+
+	// Assertions
+	assert.Equal(t, http.StatusOK, rec.Code)
+	assert.Equal(t, "Hello, World!\n", rec.Body.String())
+	assert.Equal(t, "text/plain; charset=UTF-8", rec.Header().Get("Content-Type"))
+}
+
+func BenchmarkHelloWorld(b *testing.B) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+
+	handler := func(c echo.Context) error {
+		return c.String(http.StatusOK, "Hello, World!\n")
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		_ = handler(c)
+	}
+}
\ No newline at end of file
diff --git a/cookbook/jwt/custom-claims/server.go b/cookbook/jwt/custom-claims/server.go
index c0b8adeb..b991ce04 100644
--- a/cookbook/jwt/custom-claims/server.go
+++ b/cookbook/jwt/custom-claims/server.go
@@ -1,6 +1,8 @@
 package main
 
 import (
+	"os"
+
 	"github.com/golang-jwt/jwt/v5"
 	echojwt "github.com/labstack/echo-jwt/v4"
 	"github.com/labstack/echo/v4"
@@ -39,7 +41,12 @@ func login(c echo.Context) error {
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
 
 	// Generate encoded token and send it as response.
-	t, err := token.SignedString([]byte("secret"))
+	// Get JWT secret from environment variable, fallback to default for demo
+	secret := os.Getenv("JWT_SECRET")
+	if secret == "" {
+		secret = "secret" // Default for demo purposes
+	}
+	t, err := token.SignedString([]byte(secret))
 	if err != nil {
 		return err
 	}
@@ -76,12 +83,18 @@ func main() {
 	// Restricted group
 	r := e.Group("/restricted")
 
+	// Get JWT secret from environment variable, fallback to default for demo
+	secret := os.Getenv("JWT_SECRET")
+	if secret == "" {
+		secret = "secret" // Default for demo purposes
+	}
+
 	// Configure middleware with the custom claims type
 	config := echojwt.Config{
 		NewClaimsFunc: func(c echo.Context) jwt.Claims {
 			return new(jwtCustomClaims)
 		},
-		SigningKey: []byte("secret"),
+		SigningKey: []byte(secret),
 	}
 	r.Use(echojwt.WithConfig(config))
 	r.GET("", restricted)
diff --git a/cookbook/jwt/custom-claims/server_test.go b/cookbook/jwt/custom-claims/server_test.go
new file mode 100644
index 00000000..43c125a2
--- /dev/null
+++ b/cookbook/jwt/custom-claims/server_test.go
@@ -0,0 +1,251 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	echojwt "github.com/labstack/echo-jwt/v4"
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLogin(t *testing.T) {
+	e := echo.New()
+
+	tests := []struct {
+		name         string
+		username     string
+		password     string
+		expectedCode int
+		expectToken  bool
+	}{
+		{
+			name:         "valid credentials",
+			username:     "jon",
+			password:     "shhh!",
+			expectedCode: http.StatusOK,
+			expectToken:  true,
+		},
+		{
+			name:         "invalid username",
+			username:     "invalid",
+			password:     "shhh!",
+			expectedCode: http.StatusUnauthorized,
+			expectToken:  false,
+		},
+		{
+			name:         "invalid password",
+			username:     "jon",
+			password:     "invalid",
+			expectedCode: http.StatusUnauthorized,
+			expectToken:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create form data
+			formData := "username=" + tt.username + "&password=" + tt.password
+			req := httptest.NewRequest(http.MethodPost, "/login", strings.NewReader(formData))
+			req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+			rec := httptest.NewRecorder()
+			c := e.NewContext(req, rec)
+
+			err := login(c)
+
+			if tt.expectedCode == http.StatusOK {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expectedCode, rec.Code)
+
+				if tt.expectToken {
+					var response map[string]interface{}
+					err := json.Unmarshal(rec.Body.Bytes(), &response)
+					require.NoError(t, err)
+					assert.Contains(t, response, "token")
+					assert.NotEmpty(t, response["token"])
+				}
+			} else {
+				require.Error(t, err)
+				httpErr, ok := err.(*echo.HTTPError)
+				require.True(t, ok)
+				assert.Equal(t, tt.expectedCode, httpErr.Code)
+			}
+		})
+	}
+}
+
+func TestJWTTokenGeneration(t *testing.T) {
+	// Set environment variable for test
+	os.Setenv("JWT_SECRET", "test-secret")
+	defer os.Unsetenv("JWT_SECRET")
+
+	e := echo.New()
+	formData := "username=jon&password=shhh!"
+	req := httptest.NewRequest(http.MethodPost, "/login", strings.NewReader(formData))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	err := login(c)
+	require.NoError(t, err)
+
+	var response map[string]interface{}
+	err = json.Unmarshal(rec.Body.Bytes(), &response)
+	require.NoError(t, err)
+
+	tokenString := response["token"].(string)
+
+	// Parse and validate the token
+	token, err := jwt.ParseWithClaims(tokenString, &jwtCustomClaims{}, func(token *jwt.Token) (interface{}, error) {
+		return []byte("test-secret"), nil
+	})
+
+	require.NoError(t, err)
+	require.True(t, token.Valid)
+
+	claims, ok := token.Claims.(*jwtCustomClaims)
+	require.True(t, ok)
+	assert.Equal(t, "Jon Snow", claims.Name)
+	assert.True(t, claims.Admin)
+	assert.True(t, claims.ExpiresAt.After(time.Now()))
+}
+
+func TestAccessible(t *testing.T) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	err := accessible(c)
+	require.NoError(t, err)
+	assert.Equal(t, http.StatusOK, rec.Code)
+	assert.Equal(t, "Accessible", rec.Body.String())
+}
+
+func TestRestricted(t *testing.T) {
+	// Create a valid token
+	claims := &jwtCustomClaims{
+		"Test User",
+		false,
+		jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
+		},
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/restricted", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	// Set the token in context (simulating JWT middleware)
+	c.Set("user", token)
+
+	err := restricted(c)
+	require.NoError(t, err)
+	assert.Equal(t, http.StatusOK, rec.Code)
+	assert.Equal(t, "Welcome Test User!", rec.Body.String())
+}
+
+func TestJWTIntegration(t *testing.T) {
+	// Set consistent secret for both login and verification
+	secret := "test-secret"
+	os.Setenv("JWT_SECRET", secret)
+	defer os.Unsetenv("JWT_SECRET")
+
+	// Setup Echo server with all routes
+	e := echo.New()
+	e.HideBanner = true
+
+	e.POST("/login", login)
+	e.GET("/", accessible)
+
+	// Restricted group with JWT middleware
+	r := e.Group("/restricted")
+	config := echojwt.Config{
+		NewClaimsFunc: func(c echo.Context) jwt.Claims {
+			return new(jwtCustomClaims)
+		},
+		SigningKey: []byte(secret),
+	}
+	r.Use(echojwt.WithConfig(config))
+	r.GET("", restricted)
+
+	// Test login and get token
+	formData := "username=jon&password=shhh!"
+	req := httptest.NewRequest(http.MethodPost, "/login", strings.NewReader(formData))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	rec := httptest.NewRecorder()
+
+	e.ServeHTTP(rec, req)
+
+	require.Equal(t, http.StatusOK, rec.Code)
+
+	var loginResponse map[string]interface{}
+	err := json.Unmarshal(rec.Body.Bytes(), &loginResponse)
+	require.NoError(t, err)
+
+	token := loginResponse["token"].(string)
+
+	// Test accessing restricted endpoint with token
+	req = httptest.NewRequest(http.MethodGet, "/restricted", nil)
+	req.Header.Set("Authorization", "Bearer "+token)
+	rec = httptest.NewRecorder()
+
+	e.ServeHTTP(rec, req)
+
+	assert.Equal(t, http.StatusOK, rec.Code)
+	assert.Equal(t, "Welcome Jon Snow!", rec.Body.String())
+
+	// Test accessing restricted endpoint without token
+	req = httptest.NewRequest(http.MethodGet, "/restricted", nil)
+	rec = httptest.NewRecorder()
+
+	e.ServeHTTP(rec, req)
+
+	assert.Equal(t, http.StatusUnauthorized, rec.Code)
+}
+
+func TestEnvironmentVariableSecret(t *testing.T) {
+	// Test with custom secret
+	os.Setenv("JWT_SECRET", "custom-secret")
+	defer os.Unsetenv("JWT_SECRET")
+
+	e := echo.New()
+	formData := "username=jon&password=shhh!"
+	req := httptest.NewRequest(http.MethodPost, "/login", strings.NewReader(formData))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	err := login(c)
+	require.NoError(t, err)
+
+	var response map[string]interface{}
+	err = json.Unmarshal(rec.Body.Bytes(), &response)
+	require.NoError(t, err)
+
+	tokenString := response["token"].(string)
+
+	// Verify token was signed with custom secret
+	token, err := jwt.ParseWithClaims(tokenString, &jwtCustomClaims{}, func(token *jwt.Token) (interface{}, error) {
+		return []byte("custom-secret"), nil
+	})
+
+	require.NoError(t, err)
+	require.True(t, token.Valid)
+
+	// Test with default secret should fail
+	_, err = jwt.ParseWithClaims(tokenString, &jwtCustomClaims{}, func(token *jwt.Token) (interface{}, error) {
+		return []byte("secret"), nil
+	})
+	assert.Error(t, err)
+}
\ No newline at end of file
diff --git a/cookbook/middleware/server.go b/cookbook/middleware/server.go
index f68c0471..5245e3ee 100644
--- a/cookbook/middleware/server.go
+++ b/cookbook/middleware/server.go
@@ -50,7 +50,7 @@ func (s *Stats) Handle(c echo.Context) error {
 // ServerHeader middleware adds a `Server` header to the response.
 func ServerHeader(next echo.HandlerFunc) echo.HandlerFunc {
 	return func(c echo.Context) error {
-		c.Response().Header().Set(echo.HeaderServer, "Echo/3.0")
+		c.Response().Header().Set(echo.HeaderServer, "Echo/4.11")
 		return next(c)
 	}
 }
diff --git a/cookbook/middleware/server_test.go b/cookbook/middleware/server_test.go
new file mode 100644
index 00000000..f2d64523
--- /dev/null
+++ b/cookbook/middleware/server_test.go
@@ -0,0 +1,160 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestServerHeaderMiddleware(t *testing.T) {
+	// Setup
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	// Handler that uses the middleware
+	handler := func(c echo.Context) error {
+		return c.String(http.StatusOK, "test")
+	}
+
+	// Apply middleware
+	middlewareHandler := ServerHeader(handler)
+
+	// Execute
+	if assert.NoError(t, middlewareHandler(c)) {
+		assert.Equal(t, http.StatusOK, rec.Code)
+		assert.Equal(t, "Echo/4.11", rec.Header().Get(echo.HeaderServer))
+	}
+}
+
+func TestStatsMiddleware(t *testing.T) {
+	// Setup
+	stats := NewStats()
+	e := echo.New()
+
+	// Create a simple handler
+	handler := func(c echo.Context) error {
+		return c.String(http.StatusOK, "test")
+	}
+
+	// Apply stats middleware
+	middlewareHandler := stats.Process(handler)
+
+	// Test multiple requests
+	for i := 0; i < 5; i++ {
+		req := httptest.NewRequest(http.MethodGet, "/", nil)
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+
+		assert.NoError(t, middlewareHandler(c))
+	}
+
+	// Check stats
+	assert.Equal(t, uint64(5), stats.RequestCount)
+	assert.Equal(t, 5, stats.Statuses["200"])
+}
+
+func TestStatsHandler(t *testing.T) {
+	// Setup
+	stats := NewStats()
+	e := echo.New()
+
+	// Add some test data
+	stats.RequestCount = 10
+	stats.Statuses["200"] = 8
+	stats.Statuses["404"] = 2
+
+	req := httptest.NewRequest(http.MethodGet, "/stats", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	// Execute
+	if assert.NoError(t, stats.Handle(c)) {
+		assert.Equal(t, http.StatusOK, rec.Code)
+
+		var response Stats
+		err := json.Unmarshal(rec.Body.Bytes(), &response)
+		assert.NoError(t, err)
+		assert.Equal(t, uint64(10), response.RequestCount)
+		assert.Equal(t, 8, response.Statuses["200"])
+		assert.Equal(t, 2, response.Statuses["404"])
+	}
+}
+
+func TestMainRoutes(t *testing.T) {
+	// Setup Echo server with all routes
+	e := echo.New()
+
+	// Stats
+	s := NewStats()
+	e.Use(s.Process)
+	e.GET("/stats", s.Handle)
+
+	// Server header
+	e.Use(ServerHeader)
+
+	// Handler
+	e.GET("/", func(c echo.Context) error {
+		return c.String(http.StatusOK, "Hello, World!")
+	})
+
+	tests := []struct {
+		name           string
+		method         string
+		path           string
+		expectedCode   int
+		expectedHeader string
+	}{
+		{
+			name:           "root endpoint",
+			method:         http.MethodGet,
+			path:           "/",
+			expectedCode:   http.StatusOK,
+			expectedHeader: "Echo/4.11",
+		},
+		{
+			name:         "stats endpoint",
+			method:       http.MethodGet,
+			path:         "/stats",
+			expectedCode: http.StatusOK,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest(tt.method, tt.path, nil)
+			rec := httptest.NewRecorder()
+
+			e.ServeHTTP(rec, req)
+
+			assert.Equal(t, tt.expectedCode, rec.Code)
+			if tt.expectedHeader != "" {
+				assert.Equal(t, tt.expectedHeader, rec.Header().Get(echo.HeaderServer))
+			}
+		})
+	}
+}
+
+func BenchmarkStatsMiddleware(b *testing.B) {
+	stats := NewStats()
+	e := echo.New()
+
+	handler := func(c echo.Context) error {
+		return c.String(http.StatusOK, "test")
+	}
+
+	middlewareHandler := stats.Process(handler)
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		_ = middlewareHandler(c)
+	}
+}
\ No newline at end of file
diff --git a/cookbook/performance/go.mod b/cookbook/performance/go.mod
new file mode 100644
index 00000000..fe5b393d
--- /dev/null
+++ b/cookbook/performance/go.mod
@@ -0,0 +1,25 @@
+module performance-example
+
+go 1.25.1
+
+require (
+	github.com/labstack/echo/v4 v4.11.4
+	github.com/stretchr/testify v1.8.4
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
+	github.com/labstack/gommon v0.4.2 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.2 // indirect
+	golang.org/x/crypto v0.17.0 // indirect
+	golang.org/x/net v0.19.0 // indirect
+	golang.org/x/sys v0.15.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	golang.org/x/time v0.5.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
diff --git a/cookbook/performance/go.sum b/cookbook/performance/go.sum
new file mode 100644
index 00000000..67a3c2ba
--- /dev/null
+++ b/cookbook/performance/go.sum
@@ -0,0 +1,37 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=
+github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
+github.com/labstack/echo/v4 v4.11.4 h1:vDZmA+qNeh1pd/cCkEicDMrjtrnMGQ1QFI9gWN1zGq8=
+github.com/labstack/echo/v4 v4.11.4/go.mod h1:noh7EvLwqDsmh/X/HWKPUl1AjzJrhyptRyEbQJfxen8=
+github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
+github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c=
+golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
+golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/cookbook/performance/server.go b/cookbook/performance/server.go
new file mode 100644
index 00000000..897cd8e7
--- /dev/null
+++ b/cookbook/performance/server.go
@@ -0,0 +1,229 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"runtime"
+	"time"
+
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+)
+
+// Response represents a JSON response
+type Response struct {
+	Message   string    `json:"message"`
+	Timestamp time.Time `json:"timestamp"`
+	Data      any       `json:"data,omitempty"`
+}
+
+// PerformanceMetrics holds basic performance data
+type PerformanceMetrics struct {
+	Goroutines   int           `json:"goroutines"`
+	MemAllocMB   float64       `json:"mem_alloc_mb"`
+	MemSysMB     float64       `json:"mem_sys_mb"`
+	NumGC        uint32        `json:"num_gc"`
+	ResponseTime time.Duration `json:"response_time_ms"`
+}
+
+// Simple in-memory cache for demonstration
+type Cache struct {
+	data map[string]any
+}
+
+func NewCache() *Cache {
+	return &Cache{data: make(map[string]any)}
+}
+
+func (c *Cache) Get(key string) (any, bool) {
+	val, exists := c.data[key]
+	return val, exists
+}
+
+func (c *Cache) Set(key string, value any) {
+	c.data[key] = value
+}
+
+func (c *Cache) Clear() {
+	c.data = make(map[string]any)
+}
+
+var cache = NewCache()
+
+// Fast endpoint - minimal processing
+func fast(c echo.Context) error {
+	return c.JSON(http.StatusOK, Response{
+		Message:   "Fast response",
+		Timestamp: time.Now(),
+	})
+}
+
+// Slow endpoint - simulates heavy processing
+func slow(c echo.Context) error {
+	// Simulate some processing time
+	time.Sleep(100 * time.Millisecond)
+
+	// Simulate some CPU work
+	result := 0
+	for i := 0; i < 1000000; i++ {
+		result += i
+	}
+
+	return c.JSON(http.StatusOK, Response{
+		Message:   "Slow response with processing",
+		Timestamp: time.Now(),
+		Data:      map[string]int{"calculation_result": result},
+	})
+}
+
+// Memory intensive endpoint
+func memoryIntensive(c echo.Context) error {
+	// Create a large slice to demonstrate memory usage
+	data := make([]int, 1000000)
+	for i := range data {
+		data[i] = i
+	}
+
+	// Sum to prevent optimization
+	sum := 0
+	for _, v := range data {
+		sum += v
+	}
+
+	return c.JSON(http.StatusOK, Response{
+		Message:   "Memory intensive operation completed",
+		Timestamp: time.Now(),
+		Data:      map[string]int{"sum": sum, "array_length": len(data)},
+	})
+}
+
+// Cached endpoint - demonstrates caching for performance
+func cached(c echo.Context) error {
+	key := "expensive_data"
+
+	// Check cache first
+	if cached, exists := cache.Get(key); exists {
+		return c.JSON(http.StatusOK, Response{
+			Message:   "Data from cache",
+			Timestamp: time.Now(),
+			Data:      cached,
+		})
+	}
+
+	// Simulate expensive operation
+	time.Sleep(200 * time.Millisecond)
+	expensiveData := map[string]any{
+		"computed_at": time.Now(),
+		"value":       "expensive computation result",
+		"pi":          3.14159,
+	}
+
+	// Store in cache
+	cache.Set(key, expensiveData)
+
+	return c.JSON(http.StatusOK, Response{
+		Message:   "Data computed and cached",
+		Timestamp: time.Now(),
+		Data:      expensiveData,
+	})
+}
+
+// JSON processing endpoint
+func jsonProcessing(c echo.Context) error {
+	var input map[string]any
+	if err := c.Bind(&input); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, "Invalid JSON")
+	}
+
+	// Process the JSON (transform, validate, etc.)
+	processed := make(map[string]any)
+	for k, v := range input {
+		processed[fmt.Sprintf("processed_%s", k)] = v
+	}
+
+	// Add metadata
+	processed["processing_time"] = time.Now()
+	processed["input_keys"] = len(input)
+
+	return c.JSON(http.StatusOK, Response{
+		Message:   "JSON processed successfully",
+		Timestamp: time.Now(),
+		Data:      processed,
+	})
+}
+
+// Performance metrics endpoint
+func metrics(c echo.Context) error {
+	start := time.Now()
+
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+
+	metrics := PerformanceMetrics{
+		Goroutines:   runtime.NumGoroutine(),
+		MemAllocMB:   float64(m.Alloc) / 1024 / 1024,
+		MemSysMB:     float64(m.Sys) / 1024 / 1024,
+		NumGC:        m.NumGC,
+		ResponseTime: time.Since(start),
+	}
+
+	return c.JSON(http.StatusOK, Response{
+		Message:   "Performance metrics",
+		Timestamp: time.Now(),
+		Data:      metrics,
+	})
+}
+
+// Custom middleware to measure response time
+func responseTimeMiddleware() echo.MiddlewareFunc {
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(c echo.Context) error {
+			start := time.Now()
+
+			err := next(c)
+
+			responseTime := time.Since(start)
+			c.Response().Header().Set("X-Response-Time", responseTime.String())
+
+			return err
+		}
+	}
+}
+
+func main() {
+	e := echo.New()
+
+	// Middleware
+	e.Use(middleware.Logger())
+	e.Use(middleware.Recover())
+	e.Use(responseTimeMiddleware())
+
+	// Disable Echo's default Server header for performance
+	e.HideBanner = true
+
+	// Performance-related routes
+	e.GET("/fast", fast)
+	e.GET("/slow", slow)
+	e.GET("/memory", memoryIntensive)
+	e.GET("/cached", cached)
+	e.POST("/json", jsonProcessing)
+	e.GET("/metrics", metrics)
+
+	// Health check
+	e.GET("/health", func(c echo.Context) error {
+		return c.JSON(http.StatusOK, map[string]string{"status": "ok"})
+	})
+
+	// Start server
+	fmt.Printf("Server starting on :1323\n")
+	fmt.Printf("Try these endpoints:\n")
+	fmt.Printf("  GET  /fast      - Fast endpoint\n")
+	fmt.Printf("  GET  /slow      - Slow endpoint (100ms delay)\n")
+	fmt.Printf("  GET  /memory    - Memory intensive\n")
+	fmt.Printf("  GET  /cached    - Cached endpoint\n")
+	fmt.Printf("  POST /json      - JSON processing\n")
+	fmt.Printf("  GET  /metrics   - Performance metrics\n")
+	fmt.Printf("  GET  /health    - Health check\n")
+
+	e.Logger.Fatal(e.Start(":1323"))
+}
\ No newline at end of file
diff --git a/cookbook/performance/server_test.go b/cookbook/performance/server_test.go
new file mode 100644
index 00000000..3cb8cf96
--- /dev/null
+++ b/cookbook/performance/server_test.go
@@ -0,0 +1,279 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+)
+
+// Benchmark tests
+func BenchmarkFast(b *testing.B) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/fast", nil)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		_ = fast(c)
+	}
+}
+
+func BenchmarkSlow(b *testing.B) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/slow", nil)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		_ = slow(c)
+	}
+}
+
+func BenchmarkMemoryIntensive(b *testing.B) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/memory", nil)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		_ = memoryIntensive(c)
+	}
+}
+
+func BenchmarkJSONProcessing(b *testing.B) {
+	e := echo.New()
+	jsonPayload := `{"name":"test","value":123,"data":{"nested":"value"}}`
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		req := httptest.NewRequest(http.MethodPost, "/json", strings.NewReader(jsonPayload))
+		req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		_ = jsonProcessing(c)
+	}
+}
+
+func BenchmarkCachedEndpoint(b *testing.B) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/cached", nil)
+
+	// Warm up cache
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+	_ = cached(c)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		rec := httptest.NewRecorder()
+		c := e.NewContext(req, rec)
+		_ = cached(c)
+	}
+}
+
+// Performance tests
+func TestResponseTime(t *testing.T) {
+	tests := []struct {
+		name           string
+		handler        echo.HandlerFunc
+		needsWarmup    bool
+		maxDuration    time.Duration
+		description    string
+	}{
+		{
+			name:        "fast endpoint",
+			handler:     fast,
+			needsWarmup: false,
+			maxDuration: 10 * time.Millisecond,
+			description: "should respond within 10ms",
+		},
+		{
+			name:        "cached endpoint (after warmup)",
+			handler:     cached,
+			needsWarmup: true,
+			maxDuration: 50 * time.Millisecond,
+			description: "should respond quickly from cache",
+		},
+	}
+
+	e := echo.New()
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Warm up cache if needed
+			if tt.needsWarmup {
+				req := httptest.NewRequest(http.MethodGet, "/cached", nil)
+				rec := httptest.NewRecorder()
+				c := e.NewContext(req, rec)
+				_ = cached(c)
+			}
+
+			// Measure response time
+			start := time.Now()
+
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			rec := httptest.NewRecorder()
+			c := e.NewContext(req, rec)
+
+			err := tt.handler(c)
+			duration := time.Since(start)
+
+			assert.NoError(t, err)
+			assert.LessOrEqual(t, duration, tt.maxDuration,
+				"Handler %s took %v, expected max %v", tt.name, duration, tt.maxDuration)
+		})
+	}
+}
+
+func TestCacheEffectiveness(t *testing.T) {
+	// Clear cache to ensure fresh test state
+	cache.Clear()
+
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/cached", nil)
+
+	// First call - should be slow (cache miss)
+	start1 := time.Now()
+	rec1 := httptest.NewRecorder()
+	c1 := e.NewContext(req, rec1)
+	err1 := cached(c1)
+	duration1 := time.Since(start1)
+
+	assert.NoError(t, err1)
+	assert.Equal(t, http.StatusOK, rec1.Code)
+
+	var resp1 Response
+	err := json.Unmarshal(rec1.Body.Bytes(), &resp1)
+	assert.NoError(t, err)
+	assert.Contains(t, resp1.Message, "computed")
+
+	// Second call - should be fast (cache hit)
+	start2 := time.Now()
+	rec2 := httptest.NewRecorder()
+	c2 := e.NewContext(req, rec2)
+	err2 := cached(c2)
+	duration2 := time.Since(start2)
+
+	assert.NoError(t, err2)
+	assert.Equal(t, http.StatusOK, rec2.Code)
+
+	var resp2 Response
+	err = json.Unmarshal(rec2.Body.Bytes(), &resp2)
+	assert.NoError(t, err)
+	assert.Contains(t, resp2.Message, "cache")
+
+	// Cache hit should be significantly faster
+	assert.Less(t, duration2, duration1,
+		"Cached response (%v) should be faster than computed response (%v)",
+		duration2, duration1)
+}
+
+func TestMemoryUsage(t *testing.T) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/memory", nil)
+
+	// Run memory intensive operation
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+	err := memoryIntensive(c)
+
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, rec.Code)
+
+	var response Response
+	err = json.Unmarshal(rec.Body.Bytes(), &response)
+	assert.NoError(t, err)
+	assert.Contains(t, response.Message, "Memory intensive")
+
+	// Verify response contains expected data
+	data, ok := response.Data.(map[string]interface{})
+	assert.True(t, ok)
+	assert.Contains(t, data, "sum")
+	assert.Contains(t, data, "array_length")
+}
+
+func TestMetricsEndpoint(t *testing.T) {
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	err := metrics(c)
+	assert.NoError(t, err)
+	assert.Equal(t, http.StatusOK, rec.Code)
+
+	var response Response
+	err = json.Unmarshal(rec.Body.Bytes(), &response)
+	assert.NoError(t, err)
+
+	// Verify metrics structure
+	data, ok := response.Data.(map[string]interface{})
+	assert.True(t, ok)
+	assert.Contains(t, data, "goroutines")
+	assert.Contains(t, data, "mem_alloc_mb")
+	assert.Contains(t, data, "num_gc")
+
+	// Verify reasonable values
+	goroutines := data["goroutines"].(float64)
+	assert.Greater(t, goroutines, 0.0)
+
+	memAlloc := data["mem_alloc_mb"].(float64)
+	assert.GreaterOrEqual(t, memAlloc, 0.0)
+}
+
+// Example of load testing function
+func TestConcurrentRequests(t *testing.T) {
+	e := echo.New()
+	e.Use(responseTimeMiddleware())
+	e.GET("/fast", fast)
+
+	server := httptest.NewServer(e)
+	defer server.Close()
+
+	// Test concurrent requests
+	concurrency := 10
+	requests := 100
+
+	client := &http.Client{Timeout: 5 * time.Second}
+
+	// Channel to collect results
+	results := make(chan bool, requests)
+
+	// Launch concurrent requests
+	for i := 0; i < requests; i++ {
+		go func() {
+			resp, err := client.Get(server.URL + "/fast")
+			if err != nil {
+				results <- false
+				return
+			}
+			defer resp.Body.Close()
+			results <- resp.StatusCode == http.StatusOK
+		}()
+
+		// Add slight delay every batch to control concurrency
+		if (i+1)%concurrency == 0 {
+			time.Sleep(10 * time.Millisecond)
+		}
+	}
+
+	// Collect results
+	successCount := 0
+	for i := 0; i < requests; i++ {
+		if <-results {
+			successCount++
+		}
+	}
+
+	// All requests should succeed
+	assert.Equal(t, requests, successCount)
+}
\ No newline at end of file
diff --git a/cookbook/testing/go.mod b/cookbook/testing/go.mod
new file mode 100644
index 00000000..28b08a46
--- /dev/null
+++ b/cookbook/testing/go.mod
@@ -0,0 +1,25 @@
+module testing-example
+
+go 1.25.1
+
+require (
+	github.com/labstack/echo/v4 v4.11.4
+	github.com/stretchr/testify v1.8.4
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
+	github.com/labstack/gommon v0.4.2 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/valyala/bytebufferpool v1.0.0 // indirect
+	github.com/valyala/fasttemplate v1.2.2 // indirect
+	golang.org/x/crypto v0.17.0 // indirect
+	golang.org/x/net v0.19.0 // indirect
+	golang.org/x/sys v0.15.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	golang.org/x/time v0.5.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
diff --git a/cookbook/testing/go.sum b/cookbook/testing/go.sum
new file mode 100644
index 00000000..67a3c2ba
--- /dev/null
+++ b/cookbook/testing/go.sum
@@ -0,0 +1,37 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=
+github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
+github.com/labstack/echo/v4 v4.11.4 h1:vDZmA+qNeh1pd/cCkEicDMrjtrnMGQ1QFI9gWN1zGq8=
+github.com/labstack/echo/v4 v4.11.4/go.mod h1:noh7EvLwqDsmh/X/HWKPUl1AjzJrhyptRyEbQJfxen8=
+github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
+github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c=
+golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
+golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/cookbook/testing/server.go b/cookbook/testing/server.go
new file mode 100644
index 00000000..1fdd2a17
--- /dev/null
+++ b/cookbook/testing/server.go
@@ -0,0 +1,94 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+)
+
+// User represents a user in our system
+type User struct {
+	ID    int    `json:"id"`
+	Name  string `json:"name"`
+	Email string `json:"email"`
+}
+
+// UserHandler handles user-related requests
+type UserHandler struct {
+	users map[int]*User
+}
+
+// NewUserHandler creates a new user handler
+func NewUserHandler() *UserHandler {
+	return &UserHandler{
+		users: make(map[int]*User),
+	}
+}
+
+// CreateUser creates a new user
+func (h *UserHandler) CreateUser(c echo.Context) error {
+	user := new(User)
+	if err := c.Bind(user); err != nil {
+		return echo.NewHTTPError(http.StatusBadRequest, "Invalid user data")
+	}
+
+	if user.Name == "" || user.Email == "" {
+		return echo.NewHTTPError(http.StatusBadRequest, "Name and email are required")
+	}
+
+	user.ID = len(h.users) + 1
+	h.users[user.ID] = user
+
+	return c.JSON(http.StatusCreated, user)
+}
+
+// GetUser retrieves a user by ID
+func (h *UserHandler) GetUser(c echo.Context) error {
+	id := c.Param("id")
+
+	// Simple validation for demo
+	if id == "1" {
+		user := &User{ID: 1, Name: "John Doe", Email: "john@example.com"}
+		return c.JSON(http.StatusOK, user)
+	}
+
+	return echo.NewHTTPError(http.StatusNotFound, "User not found")
+}
+
+// GetUsers returns all users
+func (h *UserHandler) GetUsers(c echo.Context) error {
+	users := make([]*User, 0, len(h.users))
+	for _, user := range h.users {
+		users = append(users, user)
+	}
+	return c.JSON(http.StatusOK, users)
+}
+
+// Health check endpoint
+func health(c echo.Context) error {
+	return c.JSON(http.StatusOK, map[string]string{
+		"status": "ok",
+		"message": "Service is healthy",
+	})
+}
+
+func main() {
+	e := echo.New()
+
+	// Middleware
+	e.Use(middleware.Logger())
+	e.Use(middleware.Recover())
+
+	// Initialize handler
+	userHandler := NewUserHandler()
+
+	// Routes
+	e.GET("/health", health)
+	e.POST("/users", userHandler.CreateUser)
+	e.GET("/users", userHandler.GetUsers)
+	e.GET("/users/:id", userHandler.GetUser)
+
+	// Start server
+	e.Logger.Fatal(e.Start(":1323"))
+}
\ No newline at end of file
diff --git a/cookbook/testing/server_test.go b/cookbook/testing/server_test.go
new file mode 100644
index 00000000..ae806233
--- /dev/null
+++ b/cookbook/testing/server_test.go
@@ -0,0 +1,203 @@
+package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHealth(t *testing.T) {
+	// Setup
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/health", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	// Assertions
+	if assert.NoError(t, health(c)) {
+		assert.Equal(t, http.StatusOK, rec.Code)
+
+		var response map[string]string
+		err := json.Unmarshal(rec.Body.Bytes(), &response)
+		assert.NoError(t, err)
+		assert.Equal(t, "ok", response["status"])
+	}
+}
+
+func TestGetUser(t *testing.T) {
+	// Setup
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/users/1", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+	c.SetParamNames("id")
+	c.SetParamValues("1")
+
+	userHandler := NewUserHandler()
+
+	// Assertions
+	if assert.NoError(t, userHandler.GetUser(c)) {
+		assert.Equal(t, http.StatusOK, rec.Code)
+
+		var user User
+		err := json.Unmarshal(rec.Body.Bytes(), &user)
+		assert.NoError(t, err)
+		assert.Equal(t, 1, user.ID)
+		assert.Equal(t, "John Doe", user.Name)
+		assert.Equal(t, "john@example.com", user.Email)
+	}
+}
+
+func TestGetUserNotFound(t *testing.T) {
+	// Setup
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/users/999", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+	c.SetParamNames("id")
+	c.SetParamValues("999")
+
+	userHandler := NewUserHandler()
+
+	// Assertions
+	err := userHandler.GetUser(c)
+	assert.Error(t, err)
+
+	// Check if it's an HTTP error with 404 status
+	httpErr, ok := err.(*echo.HTTPError)
+	assert.True(t, ok)
+	assert.Equal(t, http.StatusNotFound, httpErr.Code)
+}
+
+func TestCreateUser(t *testing.T) {
+	// Setup
+	userJSON := `{"name":"Jane Doe","email":"jane@example.com"}`
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodPost, "/users", strings.NewReader(userJSON))
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	userHandler := NewUserHandler()
+
+	// Assertions
+	if assert.NoError(t, userHandler.CreateUser(c)) {
+		assert.Equal(t, http.StatusCreated, rec.Code)
+
+		var user User
+		err := json.Unmarshal(rec.Body.Bytes(), &user)
+		assert.NoError(t, err)
+		assert.Equal(t, 1, user.ID) // First user gets ID 1
+		assert.Equal(t, "Jane Doe", user.Name)
+		assert.Equal(t, "jane@example.com", user.Email)
+	}
+}
+
+func TestCreateUserValidation(t *testing.T) {
+	tests := []struct {
+		name     string
+		payload  string
+		wantCode int
+	}{
+		{
+			name:     "missing name",
+			payload:  `{"email":"test@example.com"}`,
+			wantCode: http.StatusBadRequest,
+		},
+		{
+			name:     "missing email",
+			payload:  `{"name":"Test User"}`,
+			wantCode: http.StatusBadRequest,
+		},
+		{
+			name:     "invalid JSON",
+			payload:  `{"name":"Test User"`,
+			wantCode: http.StatusBadRequest,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup
+			e := echo.New()
+			req := httptest.NewRequest(http.MethodPost, "/users", strings.NewReader(tt.payload))
+			req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+			rec := httptest.NewRecorder()
+			c := e.NewContext(req, rec)
+
+			userHandler := NewUserHandler()
+
+			// Assertions
+			err := userHandler.CreateUser(c)
+			assert.Error(t, err)
+
+			httpErr, ok := err.(*echo.HTTPError)
+			assert.True(t, ok)
+			assert.Equal(t, tt.wantCode, httpErr.Code)
+		})
+	}
+}
+
+func TestGetUsers(t *testing.T) {
+	// Setup
+	e := echo.New()
+	req := httptest.NewRequest(http.MethodGet, "/users", nil)
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	userHandler := NewUserHandler()
+
+	// Add a test user
+	userHandler.users[1] = &User{ID: 1, Name: "Test User", Email: "test@example.com"}
+
+	// Assertions
+	if assert.NoError(t, userHandler.GetUsers(c)) {
+		assert.Equal(t, http.StatusOK, rec.Code)
+
+		var users []*User
+		err := json.Unmarshal(rec.Body.Bytes(), &users)
+		assert.NoError(t, err)
+		assert.Len(t, users, 1)
+		assert.Equal(t, "Test User", users[0].Name)
+	}
+}
+
+// Integration test example
+func TestUserAPIIntegration(t *testing.T) {
+	// Setup Echo server
+	e := echo.New()
+	userHandler := NewUserHandler()
+
+	e.POST("/users", userHandler.CreateUser)
+	e.GET("/users", userHandler.GetUsers)
+	e.GET("/users/:id", userHandler.GetUser)
+
+	// Test creating a user
+	userJSON := `{"name":"Integration Test","email":"integration@example.com"}`
+	req := httptest.NewRequest(http.MethodPost, "/users", strings.NewReader(userJSON))
+	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+	rec := httptest.NewRecorder()
+
+	e.ServeHTTP(rec, req)
+
+	assert.Equal(t, http.StatusCreated, rec.Code)
+
+	// Test getting all users
+	req = httptest.NewRequest(http.MethodGet, "/users", nil)
+	rec = httptest.NewRecorder()
+
+	e.ServeHTTP(rec, req)
+
+	assert.Equal(t, http.StatusOK, rec.Code)
+
+	var users []*User
+	err := json.Unmarshal(rec.Body.Bytes(), &users)
+	assert.NoError(t, err)
+	assert.Len(t, users, 1)
+	assert.Equal(t, "Integration Test", users[0].Name)
+}
\ No newline at end of file
diff --git a/go.mod b/go.mod
index 1d1259ba..f700f527 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
 module github.com/labstack/echox
 
-go 1.20
+go 1.25.1
 
 require (
 	github.com/GeertJohan/go.rice v1.0.3
@@ -11,6 +11,7 @@ require (
 	github.com/labstack/echo/v4 v4.11.4
 	github.com/labstack/gommon v0.4.2
 	github.com/lestrrat-go/jwx v1.2.28
+	github.com/stretchr/testify v1.8.4
 	golang.org/x/crypto v0.18.0
 	golang.org/x/net v0.20.0
 	google.golang.org/appengine v1.6.8
@@ -19,6 +20,7 @@ require (
 
 require (
 	github.com/daaku/go.zipexe v1.0.2 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/golang/protobuf v1.5.3 // indirect
@@ -32,6 +34,7 @@ require (
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rogpeppe/go-internal v1.10.0 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasttemplate v1.2.2 // indirect
@@ -41,4 +44,5 @@ require (
 	google.golang.org/protobuf v1.32.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/website/docs/cookbook/graceful-shutdown.md b/website/docs/cookbook/graceful-shutdown.md
index b54dbc42..c6d5ca20 100644
--- a/website/docs/cookbook/graceful-shutdown.md
+++ b/website/docs/cookbook/graceful-shutdown.md
@@ -4,14 +4,23 @@ description: Graceful shutdown recipe
 
 # Graceful Shutdown
 
-## Using [http.Server#Shutdown()](https://golang.org/pkg/net/http/#Server.Shutdown)
+This example demonstrates how to implement graceful shutdown using Go's `signal.NotifyContext` and Echo's `Shutdown` method to handle interrupt signals properly.
+
+## Using [signal.NotifyContext](https://pkg.go.dev/os/signal#NotifyContext) and [Echo.Shutdown](https://pkg.go.dev/github.com/labstack/echo/v4#Echo.Shutdown)
 
 ```go reference
 https://github.com/labstack/echox/blob/master/cookbook/graceful-shutdown/server.go
 ```
 
+### Key Features
+
+- Uses `signal.NotifyContext` to listen for OS interrupt signals (Ctrl+C)
+- Starts the server in a goroutine to allow non-blocking execution
+- Implements a 10-second timeout for graceful shutdown
+- Properly handles server shutdown errors
+
 :::note
 
-Requires go1.16+
+Requires Go 1.16+ for `signal.NotifyContext`. For earlier versions, use `signal.Notify` with a channel.
 
 :::
diff --git a/website/docs/cookbook/jwt.md b/website/docs/cookbook/jwt.md
index ad523f3d..426dc740 100644
--- a/website/docs/cookbook/jwt.md
+++ b/website/docs/cookbook/jwt.md
@@ -1,14 +1,18 @@
 ---
-description: JWT recipe
+description: JWT authentication examples
 ---
 
-# JWT
+# JWT Authentication
 
-[JWT middleware](../middleware/jwt.md) configuration can be found [here](../middleware/jwt.md#configuration).
+This cookbook demonstrates JWT (JSON Web Token) authentication patterns using Echo's JWT middleware. Examples include both basic authentication flows and advanced usage with custom claims and key functions.
+
+**Key Features:**
+- JWT authentication using HS256 algorithm
+- Token retrieval from `Authorization` request header
+- Custom claims handling
+- User-defined key functions for advanced scenarios
 
-This is cookbook for:
-- JWT authentication using HS256 algorithm.
-- JWT is retrieved from `Authorization` request header.
+[JWT middleware](../middleware/jwt.md) configuration can be found [here](../middleware/jwt.md#configuration).
 
 ## Server
 
diff --git a/website/docs/cookbook/performance.md b/website/docs/cookbook/performance.md
new file mode 100644
index 00000000..99b14b89
--- /dev/null
+++ b/website/docs/cookbook/performance.md
@@ -0,0 +1,220 @@
+---
+description: Performance testing and optimization
+---
+
+# Performance & Benchmarking
+
+This example demonstrates performance testing, benchmarking, and optimization techniques for Echo applications, including response time measurement, memory profiling, and load testing strategies.
+
+## Key Features
+
+- **Benchmark Testing**: Go's built-in benchmarking for performance measurement
+- **Response Time Tracking**: Custom middleware to measure request duration
+- **Memory Profiling**: Runtime memory usage monitoring
+- **Caching Strategies**: In-memory caching for improved performance
+- **Load Testing**: Concurrent request handling verification
+- **Performance Metrics**: Real-time application performance data
+
+## Server Implementation
+
+```go reference
+https://github.com/labstack/echox/blob/master/cookbook/performance/server.go
+```
+
+## Benchmark Tests
+
+```go reference
+https://github.com/labstack/echox/blob/master/cookbook/performance/server_test.go
+```
+
+## Performance Testing Patterns
+
+### 1. Benchmark Testing
+
+Use Go's built-in benchmarking to measure handler performance:
+
+```go
+func BenchmarkFast(b *testing.B) {
+    e := echo.New()
+    req := httptest.NewRequest(http.MethodGet, "/fast", nil)
+
+    b.ResetTimer()
+    for i := 0; i < b.N; i++ {
+        rec := httptest.NewRecorder()
+        c := e.NewContext(req, rec)
+        _ = fast(c)
+    }
+}
+```
+
+### 2. Response Time Middleware
+
+Track response times with custom middleware:
+
+```go
+func responseTimeMiddleware() echo.MiddlewareFunc {
+    return func(next echo.HandlerFunc) echo.HandlerFunc {
+        return func(c echo.Context) error {
+            start := time.Now()
+            err := next(c)
+            responseTime := time.Since(start)
+            c.Response().Header().Set("X-Response-Time", responseTime.String())
+            return err
+        }
+    }
+}
+```
+
+### 3. Cache Performance Testing
+
+Verify cache effectiveness by comparing response times:
+
+```go
+// First call - cache miss (slower)
+duration1 := measureResponseTime(handler)
+
+// Second call - cache hit (faster)
+duration2 := measureResponseTime(handler)
+
+assert.Less(t, duration2, duration1)
+```
+
+### 4. Memory Usage Monitoring
+
+Monitor runtime memory statistics:
+
+```go
+var m runtime.MemStats
+runtime.ReadMemStats(&m)
+
+metrics := PerformanceMetrics{
+    MemAllocMB: float64(m.Alloc) / 1024 / 1024,
+    MemSysMB:   float64(m.Sys) / 1024 / 1024,
+    NumGC:      m.NumGC,
+}
+```
+
+### 5. Concurrent Load Testing
+
+Test application under concurrent load:
+
+```go
+func TestConcurrentRequests(t *testing.T) {
+    server := httptest.NewServer(e)
+    defer server.Close()
+
+    concurrency := 10
+    requests := 100
+
+    for i := 0; i < requests; i++ {
+        go func() {
+            resp, err := client.Get(server.URL + "/endpoint")
+            // Handle response
+        }()
+    }
+}
+```
+
+## Running Performance Tests
+
+### Benchmark Tests
+```bash
+# Run all benchmarks
+go test -bench=.
+
+# Run specific benchmark
+go test -bench=BenchmarkFast
+
+# Run benchmarks with memory allocation stats
+go test -bench=. -benchmem
+
+# Run benchmarks multiple times for better accuracy
+go test -bench=. -count=5
+
+# CPU profiling during benchmarks
+go test -bench=. -cpuprofile=cpu.prof
+
+# Memory profiling during benchmarks
+go test -bench=. -memprofile=mem.prof
+```
+
+### Performance Tests
+```bash
+# Run performance tests
+go test -run TestResponseTime
+
+# Run with verbose output
+go test -v -run TestPerformance
+
+# Run load tests
+go test -run TestConcurrentRequests
+```
+
+### Profiling
+```bash
+# CPU profiling
+go tool pprof cpu.prof
+
+# Memory profiling
+go tool pprof mem.prof
+
+# Heap profiling of running server
+go tool pprof http://localhost:1323/debug/pprof/heap
+```
+
+## Performance Optimization Tips
+
+### 1. Reduce Allocations
+- Reuse objects and slices when possible
+- Use sync.Pool for expensive-to-create objects
+- Minimize string concatenation in hot paths
+
+### 2. Efficient JSON Handling
+- Use json.Decoder for streaming large payloads
+- Consider alternative JSON libraries like jsoniter
+- Avoid unnecessary marshaling/unmarshaling
+
+### 3. Middleware Optimization
+- Order middleware by frequency of use
+- Use conditional middleware when appropriate
+- Avoid expensive operations in frequently called middleware
+
+### 4. Caching Strategies
+- Implement response caching for expensive operations
+- Use appropriate cache TTL values
+- Consider distributed caching for scaled applications
+
+### 5. Database Optimization
+- Use connection pooling
+- Implement query result caching
+- Optimize database queries and indexes
+
+## Load Testing Tools
+
+### External Tools
+```bash
+# Apache Bench
+ab -n 1000 -c 10 http://localhost:1323/fast
+
+# wrk
+wrk -t4 -c100 -d30s http://localhost:1323/fast
+
+# Vegeta
+vegeta attack -duration=30s -rate=100 | vegeta report
+```
+
+### Monitoring Endpoints
+
+The example includes these monitoring endpoints:
+- `GET /metrics` - Runtime performance metrics
+- `GET /health` - Basic health check
+- All endpoints include `X-Response-Time` header
+
+## Best Practices
+
+1. **Baseline First**: Establish performance baselines before optimization
+2. **Profile Before Optimizing**: Use profiling to identify actual bottlenecks
+3. **Test Realistic Scenarios**: Use realistic data sizes and request patterns
+4. **Monitor in Production**: Implement monitoring and alerting
+5. **Gradual Optimization**: Make incremental improvements and measure impact
+6. **Documentation**: Document performance requirements and test results
\ No newline at end of file
diff --git a/website/docs/cookbook/testing.md b/website/docs/cookbook/testing.md
new file mode 100644
index 00000000..2f29a20f
--- /dev/null
+++ b/website/docs/cookbook/testing.md
@@ -0,0 +1,138 @@
+---
+description: Testing Echo applications
+---
+
+# Testing
+
+This example demonstrates comprehensive testing strategies for Echo applications, including unit tests, integration tests, and best practices for testing HTTP handlers.
+
+## Key Features
+
+- **Unit Testing**: Test individual handlers in isolation
+- **Integration Testing**: Test complete request/response cycles
+- **Validation Testing**: Test input validation and error handling
+- **HTTP Testing**: Use `httptest` package for testing HTTP functionality
+- **Table-Driven Tests**: Efficient testing of multiple scenarios
+
+## Server Implementation
+
+```go reference
+https://github.com/labstack/echox/blob/master/cookbook/testing/server.go
+```
+
+## Test Suite
+
+```go reference
+https://github.com/labstack/echox/blob/master/cookbook/testing/server_test.go
+```
+
+## Testing Patterns
+
+### 1. Unit Testing Handlers
+
+Test individual handlers by creating Echo context manually:
+
+```go
+func TestHealth(t *testing.T) {
+    // Setup
+    e := echo.New()
+    req := httptest.NewRequest(http.MethodGet, "/health", nil)
+    rec := httptest.NewRecorder()
+    c := e.NewContext(req, rec)
+
+    // Execute
+    if assert.NoError(t, health(c)) {
+        assert.Equal(t, http.StatusOK, rec.Code)
+        // Additional assertions...
+    }
+}
+```
+
+### 2. Testing with Path Parameters
+
+Set path parameters using `SetParamNames` and `SetParamValues`:
+
+```go
+c.SetParamNames("id")
+c.SetParamValues("1")
+```
+
+### 3. Testing JSON Requests
+
+Create requests with JSON payloads and proper content type:
+
+```go
+userJSON := `{"name":"Jane Doe","email":"jane@example.com"}`
+req := httptest.NewRequest(http.MethodPost, "/users", strings.NewReader(userJSON))
+req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
+```
+
+### 4. Table-Driven Tests
+
+Test multiple scenarios efficiently:
+
+```go
+tests := []struct {
+    name     string
+    payload  string
+    wantCode int
+}{
+    {"missing name", `{"email":"test@example.com"}`, http.StatusBadRequest},
+    {"missing email", `{"name":"Test User"}`, http.StatusBadRequest},
+}
+
+for _, tt := range tests {
+    t.Run(tt.name, func(t *testing.T) {
+        // Test implementation
+    })
+}
+```
+
+### 5. Integration Testing
+
+Test the complete server using `ServeHTTP`:
+
+```go
+e.ServeHTTP(rec, req)
+```
+
+## Running Tests
+
+```bash
+# Run all tests
+go test
+
+# Run tests with verbose output
+go test -v
+
+# Run specific test
+go test -run TestHealth
+
+# Run tests with coverage
+go test -cover
+
+# Generate coverage report
+go test -coverprofile=coverage.out
+go tool cover -html=coverage.out
+```
+
+## Testing Best Practices
+
+1. **Isolation**: Each test should be independent and not rely on other tests
+2. **Setup/Teardown**: Use proper setup and cleanup for each test
+3. **Clear Names**: Use descriptive test names that explain what is being tested
+4. **Edge Cases**: Test both success and failure scenarios
+5. **Coverage**: Aim for high test coverage of critical paths
+6. **Fast Tests**: Keep tests fast by avoiding external dependencies when possible
+
+## Dependencies
+
+Add testing dependencies to your `go.mod`:
+
+```go
+require (
+    github.com/stretchr/testify v1.8.4
+)
+```
+
+The `testify` package provides helpful assertion functions that make tests more readable and maintainable.
\ No newline at end of file
diff --git a/website/docs/guide/quick-start.md b/website/docs/guide/quick-start.md
index 7f7a9715..22121339 100644
--- a/website/docs/guide/quick-start.md
+++ b/website/docs/guide/quick-start.md
@@ -10,7 +10,7 @@ sidebar_position: 1
 
 ### Requirements
 
-To install Echo [Go](https://go.dev/doc/install) 1.13 or higher is required. Go 1.12 has limited support and some middlewares will not be available. Make sure your project folder is outside your $GOPATH.
+To install Echo [Go](https://go.dev/doc/install) 1.22 or higher is required. Make sure your project folder is outside your $GOPATH and uses Go modules.
 
 ```sh
 $ mkdir myapp && cd myapp
@@ -18,12 +18,6 @@ $ go mod init myapp
 $ go get github.com/labstack/echo/v4
 ```
 
-If you are working with Go v1.14 or earlier use:
-
-```sh
-$ GO111MODULE=on go get github.com/labstack/echo/v4
-```
-
 ## Hello, World!
 
 Create `server.go`
@@ -33,15 +27,25 @@ package main
 
 import (
 	"net/http"
-	
+
 	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
 )
 
 func main() {
+	// Echo instance
 	e := echo.New()
+
+	// Middleware
+	e.Use(middleware.Logger())
+	e.Use(middleware.Recover())
+
+	// Routes
 	e.GET("/", func(c echo.Context) error {
 		return c.String(http.StatusOK, "Hello, World!")
 	})
+
+	// Start server
 	e.Logger.Fatal(e.Start(":1323"))
 }
 ```
diff --git a/website/docs/introduction.md b/website/docs/introduction.md
index ec80d430..4a404e67 100644
--- a/website/docs/introduction.md
+++ b/website/docs/introduction.md
@@ -5,30 +5,38 @@ slug: /
 
 # Introduction
 
-## ![LabStack](../static/img/labstack-icon.png) Echo Project
+## ![LabStack](../static/img/labstack-icon.png) Echo Examples
 
-The Echo project is a powerful and versatile web framework for building scalable and high-performance web applications in the Go programming language. It follows the principles of simplicity, flexibility, and performance to provide developers with an efficient toolkit for building robust web applications.
+Echo Examples (echox) provides a comprehensive collection of practical examples and recipes for the Echo web framework. This repository demonstrates real-world usage patterns and best practices for building high-performance web applications with Echo v4.
 
-## Key Features
+## What You'll Find Here
 
-- **Fast and Lightweight**: Echo is designed for speed and efficiency, ensuring minimal overhead and high performance for handling HTTP requests and responses.
-- **Routing**: The framework offers a flexible and intuitive routing system that allows developers to define routes with parameters, query strings, and custom handlers.
-- **Middleware Support**: Echo provides extensive middleware support, enabling developers to easily implement cross-cutting concerns such as logging, authentication, error handling, and more.
-- **Context-based Request Handling**: With its context-based request handling, Echo offers easy access to request-specific data and parameters, simplifying the development of web applications.
-- **Powerful Template Rendering**: Echo includes a powerful template rendering engine that supports various template languages, allowing developers to generate dynamic HTML content effortlessly.
-- **Validation and Binding**: The framework provides robust validation and data binding capabilities, making it straightforward to validate incoming request data and bind it to Go structs.
-- **Extensibility**: Echo is highly extensible, with support for custom middleware, template engines, and other components, enabling developers to tailor the framework to their specific needs.
-- **Community and Ecosystem**: The Echo project benefits from a vibrant and active community that contributes libraries, plugins, and extensions, fostering an ecosystem of reusable components.
+- **22 Complete Examples**: From basic "Hello World" to advanced features like JWT authentication, WebSocket connections, and graceful shutdown
+- **Real-World Patterns**: Practical implementations of common web development scenarios
+- **Best Practices**: Production-ready code following Echo v4 conventions
+- **Modern Go**: Examples using Go 1.25+ features and current idiomatic patterns
 
-## Resources and Documentation
+## Example Categories
+
+- **Authentication & Security**: JWT, CORS, basic auth implementations
+- **File Operations**: Upload, download, and static file serving
+- **Real-time Communication**: WebSocket examples
+- **Advanced Routing**: Subdomain routing, reverse proxy, load balancing
+- **Deployment**: Auto TLS, Google App Engine, graceful shutdown
+- **Data Handling**: CRUD operations, form processing, JSON/XML binding
 
-To learn more about the Echo project, you can refer to the following resources:
+## Getting Started
 
-- Official Website: [https://echo.labstack.com](https://echo.labstack.com)
-- GitHub Repository: [https://github.com/labstack/echo](https://github.com/labstack/echo)
-- Documentation: [https://echo.labstack.com/docs](https://echo.labstack.com/guide)
-- Community Forum: [https://github.com/labstack/echo/discussions](https://github.com/labstack/echo/discussions)
+1. **Browse Examples**: Explore the cookbook section to find examples relevant to your use case
+2. **Run Locally**: Each example can be run independently with `go run server.go`
+3. **Learn Patterns**: Study the implementation patterns and adapt them to your projects
+
+## Resources and Documentation
 
-The Echo project offers an array of features that empower developers to build robust web applications. Its fast and lightweight nature ensures optimal performance, while the flexible routing system and middleware support streamline development processes. Developers can leverage the context-based request handling, powerful template rendering, and validation capabilities to create dynamic and secure web applications. Additionally, the extensibility of Echo allows developers to customize and enhance the framework to suit their specific needs.
+- **Echo Framework**: [https://echo.labstack.com](https://echo.labstack.com)
+- **Echo GitHub**: [https://github.com/labstack/echo](https://github.com/labstack/echo)
+- **Examples Repository**: [https://github.com/labstack/echox](https://github.com/labstack/echox)
+- **Community Discussions**: [https://github.com/labstack/echo/discussions](https://github.com/labstack/echo/discussions)
+- **API Documentation**: [https://pkg.go.dev/github.com/labstack/echo/v4](https://pkg.go.dev/github.com/labstack/echo/v4)
 
-Join the vibrant community of Echo developers, explore the vast ecosystem of plugins and extensions, and unleash the power of Echo for your web development needs.
+Each example in this collection demonstrates production-ready code that you can use as a foundation for your own applications. The examples cover common web development scenarios and showcase Echo's capabilities in real-world contexts.
diff --git a/website/static/img/0075-cloud.svg b/website/static/img/0075-cloud.svg
old mode 100755
new mode 100644
diff --git a/website/static/img/0101-database-upload.svg b/website/static/img/0101-database-upload.svg
old mode 100755
new mode 100644
diff --git a/website/static/img/0102-database-download.svg b/website/static/img/0102-database-download.svg
old mode 100755
new mode 100644
diff --git a/website/static/img/0221-license2.svg b/website/static/img/0221-license2.svg
old mode 100755
new mode 100644
diff --git a/website/static/img/0243-equalizer.svg b/website/static/img/0243-equalizer.svg
old mode 100755
new mode 100644
diff --git a/website/static/img/0567-speed-fast.svg b/website/static/img/0567-speed-fast.svg
old mode 100755
new mode 100644
diff --git a/website/static/img/0568-rocket.svg b/website/static/img/0568-rocket.svg
old mode 100755
new mode 100644
diff --git a/website/static/img/0780-code.svg b/website/static/img/0780-code.svg
old mode 100755
new mode 100644
diff --git a/website/static/img/0893-funnel.svg b/website/static/img/0893-funnel.svg
old mode 100755
new mode 100644