Complete tasks 4.1-4.2: Page management service and HTTP endpoints

- Implemented PageService with full CRUD operations
- Added GetPages, CreatePage, UpdatePage, DeletePage, ReorderPages methods
- Cascade deletion of widgets when page is deleted
- Prevention of last page deletion
- Created page HTTP endpoints (GET, POST, PUT, DELETE, reorder)
- HTMX-friendly HTML fragment responses
- Comprehensive unit tests for service and handlers
- Updated dashboard to use PageService and create default pages

.kiro/specs/custom-start-page/tasks.md

@@ -110,7 +110,7 @@ Each task references specific requirements from the requirements document and in
     - **Validates: Requirements 8.2, 8.3, 8.4, 8.5**
 
 - [ ] 4. Implement page management
-  - [~] 4.1 Create PageService with all CRUD operations
+  - [x] 4.1 Create PageService with all CRUD operations
     - Implement GetPages method (query by user_id, sort by order)
     - Implement CreatePage method with default "Home" page for new users
     - Implement UpdatePage method (name and order updates)
@@ -119,7 +119,7 @@ Each task references specific requirements from the requirements document and in
     - Add validation: prevent deletion of last page
     - _Requirements: 2.1, 2.2, 2.3, 2.5, 2.6, 2.7, 2.8_
 
-  - [~] 4.2 Create page HTTP endpoints
+  - [x] 4.2 Create page HTTP endpoints
     - Implement GET /dashboard (full page with page tabs)
     - Implement GET /pages/:id (returns widget grid HTML fragment)
     - Implement POST /pages (create page, returns updated tabs HTML)

cmd/server/main.go

@@ -9,6 +9,7 @@ import (
 	"custom-start-page/internal/auth"
 	"custom-start-page/internal/handlers"
 	"custom-start-page/internal/middleware"
+	"custom-start-page/internal/services"
 	"custom-start-page/internal/storage"
 	"custom-start-page/pkg/config"
 )
@@ -37,9 +38,22 @@ func main() {
 		log.Fatalf("Failed to create Users table: %v", err)
 	}
 
+	// Create Pages table if it doesn't exist
+	if err := dbClient.CreatePagesTable(ctx); err != nil {
+		log.Fatalf("Failed to create Pages table: %v", err)
+	}
+
+	// Create Widgets table if it doesn't exist
+	if err := dbClient.CreateWidgetsTable(ctx); err != nil {
+		log.Fatalf("Failed to create Widgets table: %v", err)
+	}
+
 	// Initialize repositories
 	userRepo := storage.NewUserRepository(dbClient, "Users")
 
+	// Initialize services
+	pageService := services.NewPageService(dbClient)
+
 	// Initialize auth services
 	stateStore := auth.NewMemoryStateStore()
 	oauthService := auth.NewOAuthService(
@@ -53,7 +67,8 @@ func main() {
 
 	// Initialize handlers
 	authHandler := handlers.NewAuthHandler(oauthService, userService, sessionStore)
-	dashboardHandler := handlers.NewDashboardHandler()
+	dashboardHandler := handlers.NewDashboardHandler(pageService)
+	pageHandler := handlers.NewPageHandler(pageService)
 
 	// Setup routes
 	mux := http.NewServeMux()
@@ -90,6 +105,13 @@ func main() {
 	// Protected dashboard route
 	mux.Handle("GET /dashboard", requireAuth(http.HandlerFunc(dashboardHandler.HandleDashboard)))
 
+	// Protected page routes
+	mux.Handle("GET /pages/{id}", requireAuth(http.HandlerFunc(pageHandler.HandleGetPage)))
+	mux.Handle("POST /pages", requireAuth(http.HandlerFunc(pageHandler.HandleCreatePage)))
+	mux.Handle("PUT /pages/{id}", requireAuth(http.HandlerFunc(pageHandler.HandleUpdatePage)))
+	mux.Handle("DELETE /pages/{id}", requireAuth(http.HandlerFunc(pageHandler.HandleDeletePage)))
+	mux.Handle("POST /pages/reorder", requireAuth(http.HandlerFunc(pageHandler.HandleReorderPages)))
+
 	// Start server
 	addr := fmt.Sprintf("%s:%s", cfg.Server.Host, cfg.Server.Port)
 	log.Printf("Starting server on %s", addr)

docs/task-4.1-implementation.md

@@ -0,0 +1,134 @@
+# Task 4.1 Implementation: PageService with CRUD Operations
+
+## Overview
+Implemented the PageService with all required CRUD operations for managing user pages in the Custom Start Page application.
+
+## Implementation Details
+
+### File: `internal/services/page_service.go`
+
+#### Methods Implemented
+
+1. **GetPages(ctx, userID) ([]*Page, error)**
+   - Queries all pages for a user from DynamoDB
+   - Sorts pages by their order field
+   - Returns pages in display order
+
+2. **CreatePage(ctx, userID, name) (*Page, error)**
+   - Creates a new page with a unique UUID
+   - Automatically assigns the next order number
+   - Sets timestamps (CreatedAt, UpdatedAt)
+   - Persists to DynamoDB Pages table
+
+3. **CreateDefaultPage(ctx, userID) (*Page, error)**
+   - Creates the default "Home" page for new users
+   - Wrapper around CreatePage with "Home" as the name
+   - Satisfies Requirement 2.1
+
+4. **UpdatePage(ctx, userID, pageID, name) (*Page, error)**
+   - Updates a page's name
+   - Updates the UpdatedAt timestamp
+   - Returns the updated page
+   - Uses DynamoDB UpdateItem with ReturnValues
+
+5. **DeletePage(ctx, userID, pageID) error**
+   - Validates that it's not the last page (prevents deletion)
+   - Queries all widgets associated with the page
+   - Cascade deletes all widgets in batches of 25 (DynamoDB limit)
+   - Deletes the page itself
+   - Satisfies Requirements 2.5, 2.6
+
+6. **ReorderPages(ctx, userID, pageOrder) error**
+   - Validates all page IDs exist and belong to the user
+   - Validates the order list length matches existing pages
+   - Updates each page's order field atomically
+   - Updates timestamps
+   - Satisfies Requirement 2.7
+
+#### Helper Functions
+
+- **sortPagesByOrder(pages)**: In-place bubble sort for pages by order field
+
+## Requirements Satisfied
+
+- ✅ **Requirement 2.1**: Default "Home" page creation for new users
+- ✅ **Requirement 2.2**: Page creation with name prompt
+- ✅ **Requirement 2.3**: Page name updates
+- ✅ **Requirement 2.5**: Page deletion with cascade delete of widgets
+- ✅ **Requirement 2.6**: Prevention of last page deletion
+- ✅ **Requirement 2.7**: Page reordering with persistence
+- ✅ **Requirement 2.8**: Immediate persistence to storage
+
+## Testing
+
+### Unit Tests (`internal/services/page_service_test.go`)
+
+Comprehensive test coverage including:
+
+1. **TestCreateDefaultPage**: Verifies default "Home" page creation
+2. **TestGetPages**: Tests retrieving and sorting multiple pages
+3. **TestGetPagesEmptyResult**: Tests empty result handling
+4. **TestCreatePage**: Tests page creation with auto-incrementing order
+5. **TestUpdatePage**: Tests page name updates
+6. **TestDeletePage**: Tests page deletion
+7. **TestDeleteLastPagePrevention**: Validates last page deletion prevention
+8. **TestDeletePageWithWidgets**: Tests cascade deletion of widgets
+9. **TestReorderPages**: Tests page reordering
+10. **TestReorderPagesInvalidLength**: Tests validation of order list length
+11. **TestReorderPagesInvalidPageID**: Tests validation of page IDs
+12. **TestReorderPagesPersistence**: Tests persistence of reordered pages
+
+### Unit Tests Without DynamoDB (`internal/services/page_service_unit_test.go`)
+
+Tests that don't require DynamoDB:
+
+1. **TestSortPagesByOrder**: Tests sorting function
+2. **TestSortPagesByOrderAlreadySorted**: Tests already sorted pages
+3. **TestSortPagesByOrderReversed**: Tests reversed pages
+4. **TestSortPagesByOrderEmpty**: Tests empty slice
+5. **TestSortPagesByOrderSingle**: Tests single page
+
+**Status**: All unit tests pass ✅
+
+## Key Design Decisions
+
+1. **Cascade Deletion**: When a page is deleted, all associated widgets are automatically deleted to maintain data integrity.
+
+2. **Last Page Protection**: The service prevents deletion of the last page to ensure users always have at least one page.
+
+3. **Batch Operations**: Widget deletion uses DynamoDB BatchWriteItem with batches of 25 items to handle pages with many widgets efficiently.
+
+4. **Order Management**: Pages maintain an order field that determines display sequence. The CreatePage method automatically assigns the next available order number.
+
+5. **Validation**: ReorderPages validates that all page IDs exist and belong to the user before making any changes.
+
+6. **Atomic Updates**: Each page update is atomic, ensuring consistency even with concurrent operations.
+
+## Dependencies
+
+- `github.com/aws/aws-sdk-go-v2`: AWS SDK for DynamoDB operations
+- `github.com/google/uuid`: UUID generation for page IDs
+- `github.com/stretchr/testify`: Testing assertions
+
+## Integration Points
+
+- **Storage Layer**: Uses `internal/storage/DynamoDBClient` for all database operations
+- **Models**: Uses `internal/models.Page` and `internal/models.Widget` data structures
+- **Future Integration**: Will be used by HTTP handlers in `internal/handlers` for page management endpoints
+
+## Notes
+
+- Tests require DynamoDB local running on `http://localhost:8000`
+- AWS credentials must be configured (can be dummy credentials for local testing)
+- The service is stateless and thread-safe
+- All operations use context for cancellation and timeout support
+
+## Next Steps
+
+Task 4.2 will implement the HTTP endpoints that use this service:
+- GET /dashboard
+- GET /pages/:id
+- POST /pages
+- PUT /pages/:id
+- DELETE /pages/:id
+- POST /pages/reorder

go.mod

@@ -8,7 +8,10 @@ require (
 	github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue v1.12.13
 	github.com/aws/aws-sdk-go-v2/service/dynamodb v1.26.7
 	github.com/google/uuid v1.5.0
+	github.com/gorilla/sessions v1.4.0
 	github.com/leanovate/gopter v0.2.11
+	github.com/stretchr/testify v1.11.1
+	golang.org/x/oauth2 v0.35.0
 )
 
 require (
@@ -26,9 +29,10 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.5 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sts v1.26.5 // indirect
 	github.com/aws/smithy-go v1.19.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/gorilla/securecookie v1.1.2 // indirect
-	github.com/gorilla/sessions v1.4.0 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
-	golang.org/x/oauth2 v0.35.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

internal/handlers/dashboard_handler.go

@@ -7,21 +7,26 @@ import (
 	"path/filepath"
 
 	"custom-start-page/internal/middleware"
+	"custom-start-page/internal/models"
+	"custom-start-page/internal/services"
 )
 
 // DashboardHandler handles dashboard-related HTTP requests
 type DashboardHandler struct {
-	templates *template.Template
+	pageService services.PageServiceInterface
+	templates   *template.Template
 }
 
 // NewDashboardHandler creates a new dashboard handler
-func NewDashboardHandler() *DashboardHandler {
+func NewDashboardHandler(pageService services.PageServiceInterface) *DashboardHandler {
 	// Parse templates
 	templates := template.Must(template.ParseGlob(filepath.Join("templates", "*.html")))
 	template.Must(templates.ParseGlob(filepath.Join("templates", "layouts", "*.html")))
+	template.Must(templates.ParseGlob(filepath.Join("templates", "partials", "*.html")))
 	
 	return &DashboardHandler{
-		templates: templates,
+		pageService: pageService,
+		templates:   templates,
 	}
 }
 
@@ -35,14 +40,23 @@ func (h *DashboardHandler) HandleDashboard(w http.ResponseWriter, r *http.Reques
 		return
 	}
 
-	// TODO: Fetch user's pages from database
+	// Fetch user's pages from database
-	// For now, we'll use mock data
+	pages, err := h.pageService.GetPages(r.Context(), userID)
-	pages := []map[string]interface{}{
+	if err != nil {
-		{
+		log.Printf("Failed to get pages: %v", err)
-			"ID":     "default-page",
+		http.Error(w, "Failed to load pages", http.StatusInternalServerError)
-			"Name":   "Home",
+		return
-			"Active": true,
+	}
-		},
+
+	// If user has no pages, create default "Home" page
+	if len(pages) == 0 {
+		defaultPage, err := h.pageService.CreateDefaultPage(r.Context(), userID)
+		if err != nil {
+			log.Printf("Failed to create default page: %v", err)
+			http.Error(w, "Failed to create default page", http.StatusInternalServerError)
+			return
+		}
+		pages = []*models.Page{defaultPage}
 	}
 
 	// Render dashboard template

internal/handlers/dashboard_handler_test.go

@@ -6,10 +6,67 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
+	"time"
 
 	"custom-start-page/internal/middleware"
+	"custom-start-page/internal/models"
 )
 
+// mockPageService is a mock implementation of PageService for testing
+type mockPageService struct {
+	pages []*models.Page
+	err   error
+}
+
+func (m *mockPageService) GetPages(ctx context.Context, userID string) ([]*models.Page, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	return m.pages, nil
+}
+
+func (m *mockPageService) CreatePage(ctx context.Context, userID, name string) (*models.Page, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	page := &models.Page{
+		ID:        "new-page-id",
+		UserID:    userID,
+		Name:      name,
+		Order:     len(m.pages),
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+	m.pages = append(m.pages, page)
+	return page, nil
+}
+
+func (m *mockPageService) CreateDefaultPage(ctx context.Context, userID string) (*models.Page, error) {
+	return m.CreatePage(ctx, userID, "Home")
+}
+
+func (m *mockPageService) UpdatePage(ctx context.Context, userID, pageID, name string) (*models.Page, error) {
+	if m.err != nil {
+		return nil, m.err
+	}
+	for _, page := range m.pages {
+		if page.ID == pageID && page.UserID == userID {
+			page.Name = name
+			page.UpdatedAt = time.Now()
+			return page, nil
+		}
+	}
+	return nil, nil
+}
+
+func (m *mockPageService) DeletePage(ctx context.Context, userID, pageID string) error {
+	return m.err
+}
+
+func (m *mockPageService) ReorderPages(ctx context.Context, userID string, pageOrder []string) error {
+	return m.err
+}
+
 // createMockDashboardTemplate creates a simple mock template for testing
 func createMockDashboardTemplate() *template.Template {
 	tmpl := template.New("dashboard.html")
@@ -21,8 +78,21 @@ func createMockDashboardTemplate() *template.Template {
 func TestHandleDashboard_WithAuthenticatedUser(t *testing.T) {
 	// Setup
 	mockTemplate := createMockDashboardTemplate()
+	mockPages := []*models.Page{
+		{
+			ID:        "page-1",
+			UserID:    "test-user-123",
+			Name:      "Home",
+			Order:     0,
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		},
+	}
+	mockService := &mockPageService{pages: mockPages}
+	
 	handler := &DashboardHandler{
-		templates: mockTemplate,
+		pageService: mockService,
+		templates:   mockTemplate,
 	}
 
 	// Create request with user ID in context
@@ -50,8 +120,11 @@ func TestHandleDashboard_WithAuthenticatedUser(t *testing.T) {
 func TestHandleDashboard_WithoutUserID(t *testing.T) {
 	// Setup
 	mockTemplate := createMockDashboardTemplate()
+	mockService := &mockPageService{}
+	
 	handler := &DashboardHandler{
-		templates: mockTemplate,
+		pageService: mockService,
+		templates:   mockTemplate,
 	}
 
 	// Create request without user ID in context

internal/handlers/page_handler.go

@@ -0,0 +1,275 @@
+package handlers
+
+import (
+	"encoding/json"
+	"html/template"
+	"log"
+	"net/http"
+	"path/filepath"
+
+	"custom-start-page/internal/middleware"
+	"custom-start-page/internal/services"
+)
+
+// PageHandler handles page-related HTTP requests
+type PageHandler struct {
+	pageService services.PageServiceInterface
+	templates   *template.Template
+}
+
+// NewPageHandler creates a new page handler
+func NewPageHandler(pageService services.PageServiceInterface) *PageHandler {
+	// Parse templates
+	templates := template.Must(template.ParseGlob(filepath.Join("templates", "*.html")))
+	template.Must(templates.ParseGlob(filepath.Join("templates", "layouts", "*.html")))
+	template.Must(templates.ParseGlob(filepath.Join("templates", "partials", "*.html")))
+
+	return &PageHandler{
+		pageService: pageService,
+		templates:   templates,
+	}
+}
+
+// HandleGetPage returns the widget grid HTML fragment for a specific page
+// GET /pages/:id
+func (h *PageHandler) HandleGetPage(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Get page ID from URL path
+	pageID := r.PathValue("id")
+	if pageID == "" {
+		http.Error(w, "Page ID is required", http.StatusBadRequest)
+		return
+	}
+
+	// TODO: Fetch widgets for this page
+	// For now, return empty widget grid
+	data := map[string]interface{}{
+		"PageID":  pageID,
+		"UserID":  userID,
+		"Widgets": []interface{}{},
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "widget-grid.html", data); err != nil {
+		log.Printf("Failed to render widget grid template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}
+
+// HandleCreatePage creates a new page and returns updated page tabs HTML
+// POST /pages
+func (h *PageHandler) HandleCreatePage(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Parse form data
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
+		return
+	}
+
+	pageName := r.FormValue("name")
+	if pageName == "" {
+		http.Error(w, "Page name is required", http.StatusBadRequest)
+		return
+	}
+
+	// Validate page name length
+	if len(pageName) < 1 || len(pageName) > 50 {
+		http.Error(w, "Page name must be between 1 and 50 characters", http.StatusBadRequest)
+		return
+	}
+
+	// Create the page
+	_, err := h.pageService.CreatePage(r.Context(), userID, pageName)
+	if err != nil {
+		log.Printf("Failed to create page: %v", err)
+		http.Error(w, "Failed to create page", http.StatusInternalServerError)
+		return
+	}
+
+	// Get all pages to render updated tabs
+	pages, err := h.pageService.GetPages(r.Context(), userID)
+	if err != nil {
+		log.Printf("Failed to get pages: %v", err)
+		http.Error(w, "Failed to get pages", http.StatusInternalServerError)
+		return
+	}
+
+	// Render page tabs partial
+	data := map[string]interface{}{
+		"Pages": pages,
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "page-tabs.html", data); err != nil {
+		log.Printf("Failed to render page tabs template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}
+
+// HandleUpdatePage updates a page and returns updated page tab HTML
+// PUT /pages/:id
+func (h *PageHandler) HandleUpdatePage(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Get page ID from URL path
+	pageID := r.PathValue("id")
+	if pageID == "" {
+		http.Error(w, "Page ID is required", http.StatusBadRequest)
+		return
+	}
+
+	// Parse form data
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
+		return
+	}
+
+	pageName := r.FormValue("name")
+	if pageName == "" {
+		http.Error(w, "Page name is required", http.StatusBadRequest)
+		return
+	}
+
+	// Validate page name length
+	if len(pageName) < 1 || len(pageName) > 50 {
+		http.Error(w, "Page name must be between 1 and 50 characters", http.StatusBadRequest)
+		return
+	}
+
+	// Update the page
+	page, err := h.pageService.UpdatePage(r.Context(), userID, pageID, pageName)
+	if err != nil {
+		log.Printf("Failed to update page: %v", err)
+		http.Error(w, "Failed to update page", http.StatusInternalServerError)
+		return
+	}
+
+	// Render single page tab partial
+	data := map[string]interface{}{
+		"Page": page,
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "page-tab.html", data); err != nil {
+		log.Printf("Failed to render page tab template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}
+
+// HandleDeletePage deletes a page and returns updated page tabs HTML
+// DELETE /pages/:id
+func (h *PageHandler) HandleDeletePage(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Get page ID from URL path
+	pageID := r.PathValue("id")
+	if pageID == "" {
+		http.Error(w, "Page ID is required", http.StatusBadRequest)
+		return
+	}
+
+	// Delete the page
+	err := h.pageService.DeletePage(r.Context(), userID, pageID)
+	if err != nil {
+		if err.Error() == "cannot delete the last page" {
+			http.Error(w, "Cannot delete the last page. You must have at least one page.", http.StatusBadRequest)
+			return
+		}
+		log.Printf("Failed to delete page: %v", err)
+		http.Error(w, "Failed to delete page", http.StatusInternalServerError)
+		return
+	}
+
+	// Get all pages to render updated tabs
+	pages, err := h.pageService.GetPages(r.Context(), userID)
+	if err != nil {
+		log.Printf("Failed to get pages: %v", err)
+		http.Error(w, "Failed to get pages", http.StatusInternalServerError)
+		return
+	}
+
+	// Render page tabs partial
+	data := map[string]interface{}{
+		"Pages": pages,
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "page-tabs.html", data); err != nil {
+		log.Printf("Failed to render page tabs template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}
+
+// HandleReorderPages reorders pages and returns updated page tabs HTML
+// POST /pages/reorder
+func (h *PageHandler) HandleReorderPages(w http.ResponseWriter, r *http.Request) {
+	// Get user ID from context
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	// Parse form data
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
+		return
+	}
+
+	// Get page order from form
+	orderJSON := r.FormValue("order")
+	if orderJSON == "" {
+		http.Error(w, "Page order is required", http.StatusBadRequest)
+		return
+	}
+
+	var pageOrder []string
+	if err := json.Unmarshal([]byte(orderJSON), &pageOrder); err != nil {
+		http.Error(w, "Invalid page order format", http.StatusBadRequest)
+		return
+	}
+
+	// Reorder pages
+	err := h.pageService.ReorderPages(r.Context(), userID, pageOrder)
+	if err != nil {
+		log.Printf("Failed to reorder pages: %v", err)
+		http.Error(w, "Failed to reorder pages", http.StatusInternalServerError)
+		return
+	}
+
+	// Get all pages to render updated tabs
+	pages, err := h.pageService.GetPages(r.Context(), userID)
+	if err != nil {
+		log.Printf("Failed to get pages: %v", err)
+		http.Error(w, "Failed to get pages", http.StatusInternalServerError)
+		return
+	}
+
+	// Render page tabs partial
+	data := map[string]interface{}{
+		"Pages": pages,
+	}
+
+	if err := h.templates.ExecuteTemplate(w, "page-tabs.html", data); err != nil {
+		log.Printf("Failed to render page tabs template: %v", err)
+		http.Error(w, "Internal server error", http.StatusInternalServerError)
+	}
+}

internal/handlers/page_handler_test.go

@@ -0,0 +1,251 @@
+package handlers
+
+import (
+	"context"
+	"html/template"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"custom-start-page/internal/middleware"
+)
+
+// createMockPageTemplate creates a simple mock template for testing
+func createMockPageTemplate() *template.Template {
+	tmpl := template.New("base")
+	
+	// Define page-tabs template
+	template.Must(tmpl.New("page-tabs.html").Parse(`{{define "page-tabs.html"}}{{range .Pages}}<button>{{.Name}}</button>{{end}}{{end}}`))
+	
+	// Define widget-grid template
+	template.Must(tmpl.New("widget-grid.html").Parse(`{{define "widget-grid.html"}}<div>Widgets for page {{.PageID}}</div>{{end}}`))
+	
+	// Define page-tab template
+	template.Must(tmpl.New("page-tab.html").Parse(`{{define "page-tab.html"}}<button>{{.Page.Name}}</button>{{end}}`))
+	
+	return tmpl
+}
+
+// TestHandleGetPage tests retrieving a page's widget grid
+func TestHandleGetPage(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodGet, "/pages/page-1", nil)
+	req.SetPathValue("id", "page-1")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleGetPage(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+
+	body := w.Body.String()
+	if !strings.Contains(body, "page-1") {
+		t.Errorf("Expected response to contain page ID, got: %s", body)
+	}
+}
+
+// TestHandleCreatePage tests creating a new page
+func TestHandleCreatePage(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create form data
+	form := url.Values{}
+	form.Add("name", "New Page")
+	
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodPost, "/pages", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleCreatePage(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+
+	// Verify page was created
+	if len(mockService.pages) != 1 {
+		t.Errorf("Expected 1 page to be created, got %d", len(mockService.pages))
+	}
+	
+	if mockService.pages[0].Name != "New Page" {
+		t.Errorf("Expected page name 'New Page', got '%s'", mockService.pages[0].Name)
+	}
+}
+
+// TestHandleCreatePage_InvalidName tests creating a page with invalid name
+func TestHandleCreatePage_InvalidName(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Test empty name
+	form := url.Values{}
+	form.Add("name", "")
+	
+	req := httptest.NewRequest(http.MethodPost, "/pages", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	handler.HandleCreatePage(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected status 400 for empty name, got %d", w.Code)
+	}
+
+	// Test name too long
+	form = url.Values{}
+	form.Add("name", strings.Repeat("a", 51))
+	
+	req = httptest.NewRequest(http.MethodPost, "/pages", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	ctx = context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w = httptest.NewRecorder()
+
+	handler.HandleCreatePage(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected status 400 for name too long, got %d", w.Code)
+	}
+}
+
+// TestHandleUpdatePage tests updating a page
+func TestHandleUpdatePage(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	// Create initial page
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Old Name")
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create form data
+	form := url.Values{}
+	form.Add("name", "Updated Name")
+	
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodPut, "/pages/new-page-id", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.SetPathValue("id", "new-page-id")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleUpdatePage(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+
+	// Verify page was updated
+	if mockService.pages[0].Name != "Updated Name" {
+		t.Errorf("Expected page name 'Updated Name', got '%s'", mockService.pages[0].Name)
+	}
+}
+
+// TestHandleDeletePage tests deleting a page
+func TestHandleDeletePage(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	// Create two pages
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 1")
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 2")
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodDelete, "/pages/page-1", nil)
+	req.SetPathValue("id", "page-1")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleDeletePage(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+}
+
+// TestHandleReorderPages tests reordering pages
+func TestHandleReorderPages(t *testing.T) {
+	// Setup
+	mockTemplate := createMockPageTemplate()
+	mockService := &mockPageService{}
+	
+	// Create pages
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 1")
+	_, _ = mockService.CreatePage(context.Background(), "test-user-123", "Page 2")
+	
+	handler := &PageHandler{
+		pageService: mockService,
+		templates:   mockTemplate,
+	}
+
+	// Create form data with JSON array
+	form := url.Values{}
+	form.Add("order", `["page-2", "page-1"]`)
+	
+	// Create request with user ID in context
+	req := httptest.NewRequest(http.MethodPost, "/pages/reorder", strings.NewReader(form.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	ctx := context.WithValue(req.Context(), middleware.GetUserIDContextKey(), "test-user-123")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	// Execute
+	handler.HandleReorderPages(w, req)
+
+	// Assert
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+}

internal/services/interfaces.go

@@ -0,0 +1,17 @@
+package services
+
+import (
+	"context"
+
+	"custom-start-page/internal/models"
+)
+
+// PageServiceInterface defines the interface for page operations
+type PageServiceInterface interface {
+	GetPages(ctx context.Context, userID string) ([]*models.Page, error)
+	CreatePage(ctx context.Context, userID, name string) (*models.Page, error)
+	CreateDefaultPage(ctx context.Context, userID string) (*models.Page, error)
+	UpdatePage(ctx context.Context, userID, pageID, name string) (*models.Page, error)
+	DeletePage(ctx context.Context, userID, pageID string) error
+	ReorderPages(ctx context.Context, userID string, pageOrder []string) error
+}

internal/services/page_service.go

@@ -0,0 +1,275 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
+	"github.com/google/uuid"
+
+	"custom-start-page/internal/models"
+	"custom-start-page/internal/storage"
+)
+
+// PageService handles all page-related business logic
+type PageService struct {
+	db *storage.DynamoDBClient
+}
+
+// NewPageService creates a new PageService instance
+func NewPageService(db *storage.DynamoDBClient) *PageService {
+	return &PageService{
+		db: db,
+	}
+}
+
+// GetPages retrieves all pages for a user in display order
+func (s *PageService) GetPages(ctx context.Context, userID string) ([]*models.Page, error) {
+	input := &dynamodb.QueryInput{
+		TableName:              aws.String("Pages"),
+		KeyConditionExpression: aws.String("user_id = :user_id"),
+		ExpressionAttributeValues: map[string]types.AttributeValue{
+			":user_id": &types.AttributeValueMemberS{Value: userID},
+		},
+	}
+
+	output, err := s.db.Query(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query pages: %w", err)
+	}
+
+	var pages []*models.Page
+	err = attributevalue.UnmarshalListOfMaps(output.Items, &pages)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal pages: %w", err)
+	}
+
+	// Sort by order field
+	sortPagesByOrder(pages)
+
+	return pages, nil
+}
+
+// CreatePage creates a new page for a user
+func (s *PageService) CreatePage(ctx context.Context, userID, name string) (*models.Page, error) {
+	// Get existing pages to determine the next order
+	existingPages, err := s.GetPages(ctx, userID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get existing pages: %w", err)
+	}
+
+	nextOrder := len(existingPages)
+
+	page := &models.Page{
+		ID:        uuid.New().String(),
+		UserID:    userID,
+		Name:      name,
+		Order:     nextOrder,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	item, err := attributevalue.MarshalMap(page)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal page: %w", err)
+	}
+
+	input := &dynamodb.PutItemInput{
+		TableName: aws.String("Pages"),
+		Item:      item,
+	}
+
+	err = s.db.PutItem(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create page: %w", err)
+	}
+
+	return page, nil
+}
+
+// CreateDefaultPage creates the default "Home" page for new users
+func (s *PageService) CreateDefaultPage(ctx context.Context, userID string) (*models.Page, error) {
+	return s.CreatePage(ctx, userID, "Home")
+}
+
+// UpdatePage updates a page's name or order
+func (s *PageService) UpdatePage(ctx context.Context, userID, pageID, name string) (*models.Page, error) {
+	now := time.Now()
+
+	input := &dynamodb.UpdateItemInput{
+		TableName: aws.String("Pages"),
+		Key: map[string]types.AttributeValue{
+			"user_id": &types.AttributeValueMemberS{Value: userID},
+			"page_id": &types.AttributeValueMemberS{Value: pageID},
+		},
+		UpdateExpression: aws.String("SET #name = :name, updated_at = :updated_at"),
+		ExpressionAttributeNames: map[string]string{
+			"#name": "name",
+		},
+		ExpressionAttributeValues: map[string]types.AttributeValue{
+			":name":       &types.AttributeValueMemberS{Value: name},
+			":updated_at": &types.AttributeValueMemberS{Value: now.Format(time.RFC3339)},
+		},
+		ReturnValues: types.ReturnValueAllNew,
+	}
+
+	output, err := s.db.UpdateItem(ctx, input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to update page: %w", err)
+	}
+
+	var page models.Page
+	err = attributevalue.UnmarshalMap(output.Attributes, &page)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal updated page: %w", err)
+	}
+
+	return &page, nil
+}
+
+// DeletePage deletes a page and all associated widgets
+func (s *PageService) DeletePage(ctx context.Context, userID, pageID string) error {
+	// Check if this is the last page
+	pages, err := s.GetPages(ctx, userID)
+	if err != nil {
+		return fmt.Errorf("failed to get pages: %w", err)
+	}
+
+	if len(pages) <= 1 {
+		return fmt.Errorf("cannot delete the last page")
+	}
+
+	// Get all widgets for this page
+	widgetsInput := &dynamodb.QueryInput{
+		TableName:              aws.String("Widgets"),
+		KeyConditionExpression: aws.String("page_id = :page_id"),
+		ExpressionAttributeValues: map[string]types.AttributeValue{
+			":page_id": &types.AttributeValueMemberS{Value: pageID},
+		},
+	}
+
+	widgetsOutput, err := s.db.Query(ctx, widgetsInput)
+	if err != nil {
+		return fmt.Errorf("failed to query widgets: %w", err)
+	}
+
+	// Delete all widgets in batches
+	if len(widgetsOutput.Items) > 0 {
+		var writeRequests []types.WriteRequest
+		for _, item := range widgetsOutput.Items {
+			writeRequests = append(writeRequests, types.WriteRequest{
+				DeleteRequest: &types.DeleteRequest{
+					Key: map[string]types.AttributeValue{
+						"page_id":   item["page_id"],
+						"widget_id": item["widget_id"],
+					},
+				},
+			})
+		}
+
+		// Process in batches of 25 (DynamoDB limit)
+		for i := 0; i < len(writeRequests); i += 25 {
+			end := i + 25
+			if end > len(writeRequests) {
+				end = len(writeRequests)
+			}
+
+			batchInput := &dynamodb.BatchWriteItemInput{
+				RequestItems: map[string][]types.WriteRequest{
+					"Widgets": writeRequests[i:end],
+				},
+			}
+
+			err = s.db.BatchWriteItems(ctx, batchInput)
+			if err != nil {
+				return fmt.Errorf("failed to delete widgets: %w", err)
+			}
+		}
+	}
+
+	// Delete the page
+	deleteInput := &dynamodb.DeleteItemInput{
+		TableName: aws.String("Pages"),
+		Key: map[string]types.AttributeValue{
+			"user_id": &types.AttributeValueMemberS{Value: userID},
+			"page_id": &types.AttributeValueMemberS{Value: pageID},
+		},
+	}
+
+	err = s.db.DeleteItem(ctx, deleteInput)
+	if err != nil {
+		return fmt.Errorf("failed to delete page: %w", err)
+	}
+
+	return nil
+}
+
+// ReorderPages updates the display order of pages
+func (s *PageService) ReorderPages(ctx context.Context, userID string, pageOrder []string) error {
+	// Validate that all pages exist and belong to the user
+	existingPages, err := s.GetPages(ctx, userID)
+	if err != nil {
+		return fmt.Errorf("failed to get existing pages: %w", err)
+	}
+
+	// Create a map for quick lookup
+	pageMap := make(map[string]*models.Page)
+	for _, page := range existingPages {
+		pageMap[page.ID] = page
+	}
+
+	// Validate all page IDs in the order list
+	if len(pageOrder) != len(existingPages) {
+		return fmt.Errorf("page order list length mismatch: expected %d, got %d", len(existingPages), len(pageOrder))
+	}
+
+	for _, pageID := range pageOrder {
+		if _, exists := pageMap[pageID]; !exists {
+			return fmt.Errorf("page %s not found or does not belong to user", pageID)
+		}
+	}
+
+	// Update each page's order
+	now := time.Now()
+	for i, pageID := range pageOrder {
+		input := &dynamodb.UpdateItemInput{
+			TableName: aws.String("Pages"),
+			Key: map[string]types.AttributeValue{
+				"user_id": &types.AttributeValueMemberS{Value: userID},
+				"page_id": &types.AttributeValueMemberS{Value: pageID},
+			},
+			UpdateExpression: aws.String("SET #order = :order, updated_at = :updated_at"),
+			ExpressionAttributeNames: map[string]string{
+				"#order": "order",
+			},
+			ExpressionAttributeValues: map[string]types.AttributeValue{
+				":order":      &types.AttributeValueMemberN{Value: fmt.Sprintf("%d", i)},
+				":updated_at": &types.AttributeValueMemberS{Value: now.Format(time.RFC3339)},
+			},
+		}
+
+		_, err = s.db.UpdateItem(ctx, input)
+		if err != nil {
+			return fmt.Errorf("failed to update page order for page %s: %w", pageID, err)
+		}
+	}
+
+	return nil
+}
+
+// sortPagesByOrder sorts pages by their order field (in-place)
+func sortPagesByOrder(pages []*models.Page) {
+	// Simple bubble sort since we expect small number of pages
+	n := len(pages)
+	for i := 0; i < n-1; i++ {
+		for j := 0; j < n-i-1; j++ {
+			if pages[j].Order > pages[j+1].Order {
+				pages[j], pages[j+1] = pages[j+1], pages[j]
+			}
+		}
+	}
+}

internal/services/page_service_test.go

@@ -0,0 +1,350 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
+	"github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"custom-start-page/internal/models"
+	"custom-start-page/internal/storage"
+)
+
+func setupPageServiceTest(t *testing.T) (*PageService, context.Context, func()) {
+	ctx := context.Background()
+
+	// Create DynamoDB client
+	db, err := storage.NewDynamoDBClient(ctx, "http://localhost:8000")
+	require.NoError(t, err, "Failed to create DynamoDB client")
+
+	// Create tables
+	err = db.CreatePagesTable(ctx)
+	require.NoError(t, err, "Failed to create Pages table")
+
+	err = db.CreateWidgetsTable(ctx)
+	require.NoError(t, err, "Failed to create Widgets table")
+
+	service := NewPageService(db)
+
+	cleanup := func() {
+		// Clean up test data
+		client := db.GetClient()
+		
+		// Delete Pages table
+		_, _ = client.DeleteTable(ctx, &dynamodb.DeleteTableInput{
+			TableName: aws.String("Pages"),
+		})
+		
+		// Delete Widgets table
+		_, _ = client.DeleteTable(ctx, &dynamodb.DeleteTableInput{
+			TableName: aws.String("Widgets"),
+		})
+	}
+
+	return service, ctx, cleanup
+}
+
+func TestCreateDefaultPage(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-1"
+
+	page, err := service.CreateDefaultPage(ctx, userID)
+	require.NoError(t, err)
+	assert.NotEmpty(t, page.ID)
+	assert.Equal(t, userID, page.UserID)
+	assert.Equal(t, "Home", page.Name)
+	assert.Equal(t, 0, page.Order)
+	assert.False(t, page.CreatedAt.IsZero())
+	assert.False(t, page.UpdatedAt.IsZero())
+}
+
+func TestGetPages(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-2"
+
+	// Create multiple pages
+	page1, err := service.CreatePage(ctx, userID, "Home")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Work")
+	require.NoError(t, err)
+
+	page3, err := service.CreatePage(ctx, userID, "Personal")
+	require.NoError(t, err)
+
+	// Get all pages
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Len(t, pages, 3)
+
+	// Verify pages are sorted by order
+	assert.Equal(t, page1.ID, pages[0].ID)
+	assert.Equal(t, page2.ID, pages[1].ID)
+	assert.Equal(t, page3.ID, pages[2].ID)
+
+	assert.Equal(t, 0, pages[0].Order)
+	assert.Equal(t, 1, pages[1].Order)
+	assert.Equal(t, 2, pages[2].Order)
+}
+
+func TestGetPagesEmptyResult(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-nonexistent"
+
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Empty(t, pages)
+}
+
+func TestCreatePage(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-3"
+
+	page, err := service.CreatePage(ctx, userID, "Test Page")
+	require.NoError(t, err)
+	assert.NotEmpty(t, page.ID)
+	assert.Equal(t, userID, page.UserID)
+	assert.Equal(t, "Test Page", page.Name)
+	assert.Equal(t, 0, page.Order)
+
+	// Create another page
+	page2, err := service.CreatePage(ctx, userID, "Second Page")
+	require.NoError(t, err)
+	assert.Equal(t, 1, page2.Order)
+}
+
+func TestUpdatePage(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-4"
+
+	// Create a page
+	page, err := service.CreatePage(ctx, userID, "Original Name")
+	require.NoError(t, err)
+
+	// Update the page name
+	updatedPage, err := service.UpdatePage(ctx, userID, page.ID, "Updated Name")
+	require.NoError(t, err)
+	assert.Equal(t, page.ID, updatedPage.ID)
+	assert.Equal(t, "Updated Name", updatedPage.Name)
+	assert.True(t, updatedPage.UpdatedAt.After(page.UpdatedAt) || updatedPage.UpdatedAt.Equal(page.UpdatedAt))
+}
+
+func TestDeletePage(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-5"
+
+	// Create multiple pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	// Delete page2
+	err = service.DeletePage(ctx, userID, page2.ID)
+	require.NoError(t, err)
+
+	// Verify only page1 remains
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Len(t, pages, 1)
+	assert.Equal(t, page1.ID, pages[0].ID)
+}
+
+func TestDeleteLastPagePrevention(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-6"
+
+	// Create a single page
+	page, err := service.CreatePage(ctx, userID, "Only Page")
+	require.NoError(t, err)
+
+	// Attempt to delete the last page
+	err = service.DeletePage(ctx, userID, page.ID)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "cannot delete the last page")
+
+	// Verify page still exists
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Len(t, pages, 1)
+}
+
+func TestDeletePageWithWidgets(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-7"
+
+	// Create two pages
+	_, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	// Add widgets to page2
+	db := service.db
+	for i := 0; i < 3; i++ {
+		widget := &models.Widget{
+			ID:     fmt.Sprintf("widget-%d", i),
+			PageID: page2.ID,
+			UserID: userID,
+			Type:   models.WidgetTypeBookmark,
+			Position: models.Position{X: 0, Y: i},
+			Size:     models.Size{Width: 1, Height: 1},
+			Config:   make(map[string]interface{}),
+			CreatedAt: time.Now(),
+			UpdatedAt: time.Now(),
+		}
+
+		item, err := attributevalue.MarshalMap(widget)
+		require.NoError(t, err)
+
+		err = db.PutItem(ctx, &dynamodb.PutItemInput{
+			TableName: aws.String("Widgets"),
+			Item:      item,
+		})
+		require.NoError(t, err)
+	}
+
+	// Delete page2 (should cascade delete widgets)
+	err = service.DeletePage(ctx, userID, page2.ID)
+	require.NoError(t, err)
+
+	// Verify widgets are deleted
+	widgetsOutput, err := db.Query(ctx, &dynamodb.QueryInput{
+		TableName:              aws.String("Widgets"),
+		KeyConditionExpression: aws.String("page_id = :page_id"),
+		ExpressionAttributeValues: map[string]types.AttributeValue{
+			":page_id": &types.AttributeValueMemberS{Value: page2.ID},
+		},
+	})
+	require.NoError(t, err)
+	assert.Empty(t, widgetsOutput.Items)
+}
+
+func TestReorderPages(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-8"
+
+	// Create three pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	page3, err := service.CreatePage(ctx, userID, "Page 3")
+	require.NoError(t, err)
+
+	// Reorder: page3, page1, page2
+	newOrder := []string{page3.ID, page1.ID, page2.ID}
+	err = service.ReorderPages(ctx, userID, newOrder)
+	require.NoError(t, err)
+
+	// Verify new order
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+	assert.Len(t, pages, 3)
+
+	assert.Equal(t, page3.ID, pages[0].ID)
+	assert.Equal(t, 0, pages[0].Order)
+
+	assert.Equal(t, page1.ID, pages[1].ID)
+	assert.Equal(t, 1, pages[1].Order)
+
+	assert.Equal(t, page2.ID, pages[2].ID)
+	assert.Equal(t, 2, pages[2].Order)
+}
+
+func TestReorderPagesInvalidLength(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-9"
+
+	// Create two pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	_, err = service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	// Attempt to reorder with wrong number of pages
+	err = service.ReorderPages(ctx, userID, []string{page1.ID})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "page order list length mismatch")
+}
+
+func TestReorderPagesInvalidPageID(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-10"
+
+	// Create two pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	_, err = service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	// Attempt to reorder with invalid page ID
+	err = service.ReorderPages(ctx, userID, []string{page1.ID, "invalid-page-id"})
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "not found or does not belong to user")
+}
+
+func TestReorderPagesPersistence(t *testing.T) {
+	service, ctx, cleanup := setupPageServiceTest(t)
+	defer cleanup()
+
+	userID := "test-user-11"
+
+	// Create three pages
+	page1, err := service.CreatePage(ctx, userID, "Page 1")
+	require.NoError(t, err)
+
+	page2, err := service.CreatePage(ctx, userID, "Page 2")
+	require.NoError(t, err)
+
+	page3, err := service.CreatePage(ctx, userID, "Page 3")
+	require.NoError(t, err)
+
+	// Reorder
+	newOrder := []string{page2.ID, page3.ID, page1.ID}
+	err = service.ReorderPages(ctx, userID, newOrder)
+	require.NoError(t, err)
+
+	// Retrieve pages again to verify persistence
+	pages, err := service.GetPages(ctx, userID)
+	require.NoError(t, err)
+
+	assert.Equal(t, page2.ID, pages[0].ID)
+	assert.Equal(t, page3.ID, pages[1].ID)
+	assert.Equal(t, page1.ID, pages[2].ID)
+}

internal/services/page_service_unit_test.go

@@ -0,0 +1,73 @@
+package services
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"custom-start-page/internal/models"
+)
+
+// TestSortPagesByOrder tests the sorting function without requiring DynamoDB
+func TestSortPagesByOrder(t *testing.T) {
+	pages := []*models.Page{
+		{ID: "page-3", Order: 2},
+		{ID: "page-1", Order: 0},
+		{ID: "page-2", Order: 1},
+	}
+
+	sortPagesByOrder(pages)
+
+	assert.Equal(t, "page-1", pages[0].ID)
+	assert.Equal(t, "page-2", pages[1].ID)
+	assert.Equal(t, "page-3", pages[2].ID)
+}
+
+// TestSortPagesByOrderAlreadySorted tests sorting already sorted pages
+func TestSortPagesByOrderAlreadySorted(t *testing.T) {
+	pages := []*models.Page{
+		{ID: "page-1", Order: 0},
+		{ID: "page-2", Order: 1},
+		{ID: "page-3", Order: 2},
+	}
+
+	sortPagesByOrder(pages)
+
+	assert.Equal(t, "page-1", pages[0].ID)
+	assert.Equal(t, "page-2", pages[1].ID)
+	assert.Equal(t, "page-3", pages[2].ID)
+}
+
+// TestSortPagesByOrderReversed tests sorting reversed pages
+func TestSortPagesByOrderReversed(t *testing.T) {
+	pages := []*models.Page{
+		{ID: "page-3", Order: 2},
+		{ID: "page-2", Order: 1},
+		{ID: "page-1", Order: 0},
+	}
+
+	sortPagesByOrder(pages)
+
+	assert.Equal(t, "page-1", pages[0].ID)
+	assert.Equal(t, "page-2", pages[1].ID)
+	assert.Equal(t, "page-3", pages[2].ID)
+}
+
+// TestSortPagesByOrderEmpty tests sorting empty slice
+func TestSortPagesByOrderEmpty(t *testing.T) {
+	pages := []*models.Page{}
+	sortPagesByOrder(pages)
+	assert.Empty(t, pages)
+}
+
+// TestSortPagesByOrderSingle tests sorting single page
+func TestSortPagesByOrderSingle(t *testing.T) {
+	pages := []*models.Page{
+		{ID: "page-1", Order: 0},
+	}
+
+	sortPagesByOrder(pages)
+
+	assert.Len(t, pages, 1)
+	assert.Equal(t, "page-1", pages[0].ID)
+}

templates/dashboard.html

@@ -48,19 +48,7 @@
             
             <!-- Page Tabs -->
             <div id="page-tabs" class="flex space-x-1 -mb-px">
-                {{range .Pages}}
+                {{template "page-tabs.html" .}}
-                <button hx-get="/pages/{{.ID}}" 
-                        hx-target="#widget-grid" 
-                        hx-swap="innerHTML"
-                        class="px-4 py-2 text-sm font-medium {{if .Active}}border-b-2 border-blue-500 text-blue-600{{else}}text-gray-600 hover:text-gray-800{{end}}">
-                    {{.Name}}
-                </button>
-                {{end}}
-                <button class="px-4 py-2 text-sm font-medium text-gray-400 hover:text-gray-600">
-                    <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/>
-                    </svg>
-                </button>
             </div>
         </div>
     </header>

templates/partials/page-tab.html

@@ -0,0 +1,10 @@
+{{define "page-tab.html"}}
+<button hx-get="/pages/{{.Page.ID}}" 
+        hx-target="#widget-grid" 
+        hx-swap="innerHTML"
+        hx-push-url="false"
+        data-page-id="{{.Page.ID}}"
+        class="page-tab px-4 py-2 text-sm font-medium text-gray-600 hover:text-gray-800 border-b-2 border-transparent hover:border-gray-300 transition-colors">
+    {{.Page.Name}}
+</button>
+{{end}}

templates/partials/page-tabs.html

@@ -0,0 +1,21 @@
+{{define "page-tabs.html"}}
+{{range .Pages}}
+<button hx-get="/pages/{{.ID}}" 
+        hx-target="#widget-grid" 
+        hx-swap="innerHTML"
+        hx-push-url="false"
+        data-page-id="{{.ID}}"
+        class="page-tab px-4 py-2 text-sm font-medium text-gray-600 hover:text-gray-800 border-b-2 border-transparent hover:border-gray-300 transition-colors">
+    {{.Name}}
+</button>
+{{end}}
+<button hx-get="/pages/new-form" 
+        hx-target="#page-form-modal" 
+        hx-swap="innerHTML"
+        class="px-4 py-2 text-sm font-medium text-gray-400 hover:text-gray-600 transition-colors"
+        title="Add new page">
+    <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/>
+    </svg>
+</button>
+{{end}}

templates/partials/widget-grid.html

@@ -0,0 +1,34 @@
+{{define "widget-grid.html"}}
+{{if .Widgets}}
+    {{range .Widgets}}
+    <div class="widget bg-white rounded-lg shadow-sm border border-gray-200 p-4" data-widget-id="{{.ID}}">
+        <div class="widget-handle cursor-move mb-2 flex items-center justify-between">
+            <h3 class="text-lg font-semibold text-gray-800">
+                {{if .Title}}{{.Title}}{{else}}{{.Type}} Widget{{end}}
+            </h3>
+            <button hx-delete="/widgets/{{.ID}}" 
+                    hx-target="closest .widget" 
+                    hx-swap="outerHTML swap:1s"
+                    hx-confirm="Are you sure you want to delete this widget?"
+                    class="text-gray-400 hover:text-red-600 transition-colors">
+                <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/>
+                </svg>
+            </button>
+        </div>
+        <div class="widget-content">
+            <!-- Widget-specific content will be loaded here -->
+            <p class="text-gray-500 text-sm">{{.Type}} widget content</p>
+        </div>
+    </div>
+    {{end}}
+{{else}}
+    <div class="col-span-full text-center text-gray-500 py-12">
+        <svg class="w-16 h-16 mx-auto mb-4 text-gray-300" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M20 13V6a2 2 0 00-2-2H6a2 2 0 00-2 2v7m16 0v5a2 2 0 01-2 2H6a2 2 0 01-2-2v-5m16 0h-2.586a1 1 0 00-.707.293l-2.414 2.414a1 1 0 01-.707.293h-3.172a1 1 0 01-.707-.293l-2.414-2.414A1 1 0 006.586 13H4"/>
+        </svg>
+        <p class="text-lg font-medium mb-2">No widgets yet</p>
+        <p class="text-sm">Click the + button to add your first widget</p>
+    </div>
+{{end}}
+{{end}}