diff --git a/CLAUDE.md b/CLAUDE.md
index 783a84f..641a901 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,4 +1,4 @@
-# Claude Code Task Management Guide
+# Codespace Task Management Guide
 
 ## Documentation Available
 
diff --git a/app/dashboard/data.json b/app/dashboard/data.json
index ec08736..80e9a7e 100644
--- a/app/dashboard/data.json
+++ b/app/dashboard/data.json
@@ -1,4 +1,5 @@
-[
+{
+  "documents": [
   {
     "id": 1,
     "header": "Cover page",
@@ -611,4 +612,122 @@
     "limit": "29",
     "reviewer": "Assign reviewer"
   }
-]
+  ],
+  "kanban": {
+    "boards": [
+      {
+        "id": "main-board",
+        "title": "Project Management Board",
+        "description": "Main kanban board for tracking project tasks",
+        "createdAt": "2024-01-01T00:00:00Z",
+        "updatedAt": "2024-01-15T10:30:00Z",
+        "columns": [
+          {
+            "id": "todo-column",
+            "title": "To Do",
+            "status": "todo",
+            "maxTasks": 10,
+            "tasks": [
+              {
+                "id": "task-1",
+                "title": "Design user authentication flow",
+                "description": "Create wireframes and user flow for the authentication system",
+                "status": "todo",
+                "priority": "high",
+                "assignee": "Sarah Johnson",
+                "createdAt": "2024-01-01T09:00:00Z",
+                "updatedAt": "2024-01-01T09:00:00Z",
+                "dueDate": "2024-01-20T17:00:00Z"
+              },
+              {
+                "id": "task-2",
+                "title": "Set up development environment",
+                "description": "Configure Docker containers and development tools",
+                "status": "todo",
+                "priority": "medium",
+                "assignee": "Mike Chen",
+                "createdAt": "2024-01-02T10:00:00Z",
+                "updatedAt": "2024-01-02T10:00:00Z"
+              },
+              {
+                "id": "task-3",
+                "title": "Research accessibility requirements",
+                "description": "Investigate WCAG guidelines and compliance needs",
+                "status": "todo",
+                "priority": "medium",
+                "createdAt": "2024-01-03T11:00:00Z",
+                "updatedAt": "2024-01-03T11:00:00Z"
+              }
+            ]
+          },
+          {
+            "id": "inprogress-column",
+            "title": "In Progress",
+            "status": "in-progress",
+            "maxTasks": 5,
+            "tasks": [
+              {
+                "id": "task-4",
+                "title": "Implement user registration API",
+                "description": "Build REST endpoints for user registration with validation",
+                "status": "in-progress",
+                "priority": "high",
+                "assignee": "Alex Rodriguez",
+                "createdAt": "2024-01-04T08:00:00Z",
+                "updatedAt": "2024-01-10T14:30:00Z",
+                "dueDate": "2024-01-18T17:00:00Z"
+              },
+              {
+                "id": "task-5",
+                "title": "Create dashboard mockups",
+                "description": "Design main dashboard layout and components",
+                "status": "in-progress",
+                "priority": "medium",
+                "assignee": "Emma Davis",
+                "createdAt": "2024-01-05T09:30:00Z",
+                "updatedAt": "2024-01-12T16:45:00Z"
+              }
+            ]
+          },
+          {
+            "id": "done-column",
+            "title": "Done",
+            "status": "done",
+            "tasks": [
+              {
+                "id": "task-6",
+                "title": "Project planning and requirements",
+                "description": "Gather and document all project requirements",
+                "status": "done",
+                "priority": "high",
+                "assignee": "Lisa Wong",
+                "createdAt": "2023-12-20T10:00:00Z",
+                "updatedAt": "2024-01-05T15:00:00Z"
+              },
+              {
+                "id": "task-7",
+                "title": "Database schema design",
+                "description": "Design and implement the database schema",
+                "status": "done",
+                "priority": "high",
+                "assignee": "David Kim",
+                "createdAt": "2023-12-22T11:00:00Z",
+                "updatedAt": "2024-01-08T12:30:00Z"
+              },
+              {
+                "id": "task-8",
+                "title": "Set up CI/CD pipeline",
+                "description": "Configure automated testing and deployment",
+                "status": "done",
+                "priority": "medium",
+                "assignee": "James Wilson",
+                "createdAt": "2023-12-25T14:00:00Z",
+                "updatedAt": "2024-01-07T09:15:00Z"
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/app/dashboard/kanban/kanban.css b/app/dashboard/kanban/kanban.css
new file mode 100644
index 0000000..ea5072d
--- /dev/null
+++ b/app/dashboard/kanban/kanban.css
@@ -0,0 +1,95 @@
+/* Import kanban component styles */
+@import '../../../components/kanban/kanban.css';
+
+/* Kanban Page Specific Styles */
+.kanban-page {
+  @apply min-h-screen bg-background;
+  overflow: hidden;
+}
+
+.kanban-page .kanban-board {
+  height: calc(100vh - var(--header-height, 64px));
+  padding: 1rem;
+}
+
+/* Override scrollbar for kanban page */
+.kanban-page .kanban-scroll {
+  scrollbar-width: thin;
+  scrollbar-color: hsl(var(--muted-foreground)) hsl(var(--background));
+}
+
+.kanban-page .kanban-scroll::-webkit-scrollbar {
+  height: 6px;
+}
+
+.kanban-page .kanban-scroll::-webkit-scrollbar-track {
+  background: hsl(var(--background));
+  border-radius: 3px;
+}
+
+.kanban-page .kanban-scroll::-webkit-scrollbar-thumb {
+  background: hsl(var(--muted));
+  border-radius: 3px;
+}
+
+.kanban-page .kanban-scroll::-webkit-scrollbar-thumb:hover {
+  background: hsl(var(--muted-foreground));
+}
+
+/* Loading state */
+.kanban-loading {
+  @apply flex items-center justify-center h-full;
+}
+
+.kanban-loading-spinner {
+  @apply animate-spin rounded-full h-8 w-8 border-b-2 border-primary;
+}
+
+/* Error state */
+.kanban-error {
+  @apply flex items-center justify-center h-full text-center;
+}
+
+.kanban-error-icon {
+  @apply w-8 h-8 text-red-600 mx-auto mb-2;
+}
+
+/* Responsive adjustments for kanban page */
+@media (max-width: 768px) {
+  .kanban-page .kanban-board {
+    padding: 0.5rem;
+    height: calc(100vh - var(--header-height, 64px) - 1rem);
+  }
+
+  .kanban-page .kanban-columns {
+    gap: 1rem;
+    padding: 0.5rem;
+  }
+
+  .kanban-page .kanban-column {
+    min-width: 280px;
+    max-width: 280px;
+  }
+}
+
+@media (max-width: 640px) {
+  .kanban-page .kanban-board {
+    height: calc(100vh - var(--header-height, 56px) - 0.5rem);
+  }
+  
+  .kanban-page .kanban-column {
+    min-width: 260px;
+    max-width: 260px;
+  }
+}
+
+/* Dark mode adjustments */
+@media (prefers-color-scheme: dark) {
+  .kanban-page {
+    background-color: hsl(var(--background));
+  }
+
+  .kanban-page .task-card:hover {
+    box-shadow: 0 4px 12px rgba(255, 255, 255, 0.1);
+  }
+}
\ No newline at end of file
diff --git a/app/dashboard/kanban/page.tsx b/app/dashboard/kanban/page.tsx
new file mode 100644
index 0000000..62f6edf
--- /dev/null
+++ b/app/dashboard/kanban/page.tsx
@@ -0,0 +1,95 @@
+'use client'
+
+import * as React from 'react'
+import { KanbanBoard } from '@/components/kanban'
+import { KanbanData, KanbanBoard as KanbanBoardType } from '@/types/kanban'
+import data from '../data.json'
+import './kanban.css'
+
+// This would normally come from metadata API route, but we'll set it here for now
+const pageMetadata = {
+  title: 'Kanban Board - CodeGuide',
+  description: 'Manage your tasks and projects with our interactive Kanban board'
+}
+
+export default function KanbanPage() {
+  const [boardData, setBoardData] = React.useState<KanbanBoardType | null>(null)
+  const [isLoading, setIsLoading] = React.useState(true)
+  const [error, setError] = React.useState<string | null>(null)
+
+  React.useEffect(() => {
+    // Set document title
+    document.title = pageMetadata.title
+    
+    try {
+      const kanbanData = data.kanban as KanbanData
+      if (kanbanData.boards && kanbanData.boards.length > 0) {
+        setBoardData(kanbanData.boards[0])
+      } else {
+        setError('No kanban boards found')
+      }
+    } catch (err) {
+      setError('Failed to load kanban data')
+      console.error('Error loading kanban data:', err)
+    } finally {
+      setIsLoading(false)
+    }
+  }, [])
+
+  const handleBoardChange = React.useCallback((updatedBoard: KanbanBoardType) => {
+    setBoardData(updatedBoard)
+    // In a real app, you might want to save to an API here
+    console.log('Board updated:', updatedBoard)
+  }, [])
+
+  if (isLoading) {
+    return (
+      <div className="flex items-center justify-center h-full min-h-[400px]">
+        <div className="text-center space-y-4">
+          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary mx-auto" />
+          <p className="text-muted-foreground">Loading kanban board...</p>
+        </div>
+      </div>
+    )
+  }
+
+  if (error || !boardData) {
+    return (
+      <div className="flex items-center justify-center h-full min-h-[400px]">
+        <div className="text-center space-y-4">
+          <div className="rounded-full bg-red-100 p-3 w-16 h-16 flex items-center justify-center mx-auto">
+            <svg
+              className="w-8 h-8 text-red-600"
+              fill="none"
+              stroke="currentColor"
+              viewBox="0 0 24 24"
+            >
+              <path
+                strokeLinecap="round"
+                strokeLinejoin="round"
+                strokeWidth={2}
+                d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-2.5L13.732 4c-.77-.833-1.732-.833-2.464 0L3.34 16.5c-.77.833.192 2.5 1.732 2.5z"
+              />
+            </svg>
+          </div>
+          <div>
+            <h3 className="text-lg font-semibold">Failed to load kanban board</h3>
+            <p className="text-muted-foreground mt-1">
+              {error || 'An unexpected error occurred'}
+            </p>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="h-full flex flex-col kanban-page">
+      <KanbanBoard 
+        initialBoard={boardData}
+        onBoardChange={handleBoardChange}
+        className="flex-1"
+      />
+    </div>
+  )
+}
\ No newline at end of file
diff --git a/components/app-sidebar.tsx b/components/app-sidebar.tsx
index 42d379d..7c119d5 100644
--- a/components/app-sidebar.tsx
+++ b/components/app-sidebar.tsx
@@ -19,6 +19,7 @@ import {
   IconSearch,
   IconSettings,
   IconUsers,
+  IconLayoutKanban,
 } from "@tabler/icons-react"
 
 import { NavDocuments } from "@/components/nav-documents"
@@ -39,9 +40,14 @@ const staticData = {
   navMain: [
     {
       title: "Dashboard",
-      url: "#",
+      url: "/dashboard",
       icon: IconDashboard,
     },
+    {
+      title: "Kanban Board",
+      url: "/dashboard/kanban",
+      icon: IconLayoutKanban,
+    },
     {
       title: "Lifecycle",
       url: "#",
diff --git a/components/kanban/KanbanBoard.tsx b/components/kanban/KanbanBoard.tsx
new file mode 100644
index 0000000..ed4e53f
--- /dev/null
+++ b/components/kanban/KanbanBoard.tsx
@@ -0,0 +1,194 @@
+'use client'
+
+import * as React from 'react'
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
+import { Button } from '@/components/ui/button'
+import { Plus, MoreHorizontal } from 'lucide-react'
+import { cn } from '@/lib/utils'
+import { KanbanBoard as KanbanBoardType, KanbanTask } from '@/types/kanban'
+import { KanbanColumn } from './KanbanColumn'
+import { TaskModal } from './TaskModal'
+import { useKanbanState } from '@/hooks/useKanbanState'
+
+interface KanbanBoardProps {
+  initialBoard: KanbanBoardType
+  onBoardChange?: (board: KanbanBoardType) => void
+  className?: string
+}
+
+export function KanbanBoard({ 
+  initialBoard, 
+  onBoardChange,
+  className 
+}: KanbanBoardProps) {
+  const { 
+    board, 
+    moveTask, 
+    deleteTask, 
+    saveTaskChanges,
+    getTask,
+    getColumn
+  } = useKanbanState(initialBoard)
+
+  const [draggedTaskId, setDraggedTaskId] = React.useState<string | null>(null)
+  const [taskModal, setTaskModal] = React.useState<{
+    isOpen: boolean
+    mode: 'create' | 'edit'
+    task?: KanbanTask | null
+    columnId?: string
+  }>({
+    isOpen: false,
+    mode: 'create',
+    task: null,
+    columnId: undefined
+  })
+
+  // Notify parent component when board changes
+  React.useEffect(() => {
+    onBoardChange?.(board)
+  }, [board, onBoardChange])
+
+  const handleDragStart = (taskId: string) => {
+    setDraggedTaskId(taskId)
+  }
+
+  const handleDragEnd = () => {
+    setDraggedTaskId(null)
+  }
+
+  const handleTaskDrop = (taskId: string, newColumnId: string) => {
+    const sourceColumn = board.columns.find(col => 
+      col.tasks.some(task => task.id === taskId)
+    )
+    
+    const targetColumn = board.columns.find(col => col.id === newColumnId)
+    
+    if (!sourceColumn || !targetColumn || sourceColumn.id === newColumnId) {
+      return
+    }
+
+    moveTask(taskId, newColumnId, targetColumn.status)
+  }
+
+  const handleTaskEdit = (task: KanbanTask) => {
+    setTaskModal({
+      isOpen: true,
+      mode: 'edit',
+      task,
+      columnId: undefined
+    })
+  }
+
+  const handleTaskDelete = (taskId: string) => {
+    if (window.confirm('Are you sure you want to delete this task?')) {
+      deleteTask(taskId)
+    }
+  }
+
+  const handleTaskAdd = (columnId: string) => {
+    const column = getColumn(columnId)
+    setTaskModal({
+      isOpen: true,
+      mode: 'create',
+      task: null,
+      columnId
+    })
+  }
+
+  const handleModalClose = () => {
+    setTaskModal({
+      isOpen: false,
+      mode: 'create',
+      task: null,
+      columnId: undefined
+    })
+  }
+
+  const handleTaskSave = (taskData: Partial<KanbanTask>) => {
+    saveTaskChanges(taskData, taskModal.columnId)
+  }
+
+  return (
+    <div 
+      className={cn('flex flex-col h-full kanban-board', className)}
+      data-dragging={draggedTaskId !== null}
+    >
+      {/* Board Header */}
+      <Card className="mb-6">
+        <CardHeader>
+          <div className="flex items-center justify-between">
+            <div>
+              <CardTitle className="text-xl font-bold">
+                {board.title}
+              </CardTitle>
+              {board.description && (
+                <p className="text-sm text-muted-foreground mt-1">
+                  {board.description}
+                </p>
+              )}
+            </div>
+            
+            <div className="flex items-center gap-2">
+              <Button 
+                variant="outline" 
+                size="sm"
+                onClick={() => handleTaskAdd(board.columns[0]?.id)}
+                disabled={!board.columns.length}
+              >
+                <Plus className="h-4 w-4 mr-2" />
+                Add Task
+              </Button>
+              <Button variant="ghost" size="sm">
+                <MoreHorizontal className="h-4 w-4" />
+              </Button>
+            </div>
+          </div>
+        </CardHeader>
+      </Card>
+
+      {/* Kanban Columns */}
+      <div className="flex-1 overflow-hidden">
+        <div className="h-full overflow-x-auto">
+          <div className="flex gap-6 h-full min-w-max px-1 pb-6">
+            {board.columns.map((column) => (
+              <KanbanColumn
+                key={column.id}
+                column={column}
+                onTaskEdit={handleTaskEdit}
+                onTaskDelete={handleTaskDelete}
+                onTaskAdd={handleTaskAdd}
+                onTaskDrop={handleTaskDrop}
+                onDragStart={handleDragStart}
+                onDragEnd={handleDragEnd}
+                draggedTaskId={draggedTaskId}
+              />
+            ))}
+            
+            {/* Add Column Button */}
+            <div className="min-w-80 max-w-80">
+              <Card className="h-32 border-dashed border-2 hover:border-primary/50 transition-colors cursor-pointer">
+                <CardContent className="h-full flex items-center justify-center">
+                  <Button variant="ghost" className="text-muted-foreground">
+                    <Plus className="h-4 w-4 mr-2" />
+                    Add Column
+                  </Button>
+                </CardContent>
+              </Card>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* Task Modal */}
+      <TaskModal
+        isOpen={taskModal.isOpen}
+        onClose={handleModalClose}
+        onSave={handleTaskSave}
+        task={taskModal.task}
+        mode={taskModal.mode}
+        columnId={taskModal.columnId}
+        columnStatus={taskModal.columnId ? getColumn(taskModal.columnId)?.status : 'todo'}
+      />
+    </div>
+  )
+}
\ No newline at end of file
diff --git a/components/kanban/KanbanColumn.tsx b/components/kanban/KanbanColumn.tsx
new file mode 100644
index 0000000..e8fd761
--- /dev/null
+++ b/components/kanban/KanbanColumn.tsx
@@ -0,0 +1,167 @@
+'use client'
+
+import * as React from 'react'
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Plus } from 'lucide-react'
+import { cn } from '@/lib/utils'
+import { KanbanColumn as KanbanColumnType, KanbanTask } from '@/types/kanban'
+import { TaskCard } from './TaskCard'
+
+interface KanbanColumnProps {
+  column: KanbanColumnType
+  onTaskEdit?: (task: KanbanTask) => void
+  onTaskDelete?: (taskId: string) => void
+  onTaskAdd?: (columnId: string) => void
+  onTaskDrop?: (taskId: string, newColumnId: string) => void
+  onDragStart?: (taskId: string) => void
+  onDragEnd?: () => void
+  isDragOver?: boolean
+  draggedTaskId?: string | null
+}
+
+export function KanbanColumn({ 
+  column, 
+  onTaskEdit, 
+  onTaskDelete, 
+  onTaskAdd,
+  onTaskDrop,
+  onDragStart,
+  onDragEnd,
+  isDragOver = false,
+  draggedTaskId
+}: KanbanColumnProps) {
+  const [draggedOver, setDraggedOver] = React.useState(false)
+  const [dragDepth, setDragDepth] = React.useState(0)
+
+  const handleDragOver = (e: React.DragEvent) => {
+    e.preventDefault()
+    e.dataTransfer.dropEffect = 'move'
+    
+    // Only show drag over state if the dragged task isn't already in this column
+    const taskId = e.dataTransfer.getData('text/plain') || draggedTaskId
+    const taskExistsInColumn = column.tasks.some(task => task.id === taskId)
+    
+    if (!taskExistsInColumn) {
+      setDraggedOver(true)
+    }
+  }
+
+  const handleDragEnter = (e: React.DragEvent) => {
+    e.preventDefault()
+    setDragDepth(prev => prev + 1)
+  }
+
+  const handleDragLeave = (e: React.DragEvent) => {
+    e.preventDefault()
+    setDragDepth(prev => {
+      const newDepth = prev - 1
+      if (newDepth <= 0) {
+        setDraggedOver(false)
+      }
+      return Math.max(0, newDepth)
+    })
+  }
+
+  const handleDrop = (e: React.DragEvent) => {
+    e.preventDefault()
+    setDraggedOver(false)
+    setDragDepth(0)
+    
+    const taskId = e.dataTransfer.getData('text/plain')
+    if (taskId && onTaskDrop) {
+      // Check if task is not already in this column
+      const taskExistsInColumn = column.tasks.some(task => task.id === taskId)
+      if (!taskExistsInColumn) {
+        onTaskDrop(taskId, column.id)
+      }
+    }
+  }
+
+  const getColumnColor = (status: string) => {
+    switch (status) {
+      case 'todo':
+        return 'bg-slate-100 text-slate-800'
+      case 'in-progress':
+        return 'bg-blue-100 text-blue-800'
+      case 'done':
+        return 'bg-green-100 text-green-800'
+      default:
+        return 'bg-gray-100 text-gray-800'
+    }
+  }
+
+  return (
+    <div className="flex flex-col h-full min-w-80 max-w-80">
+      <Card className="flex-1 flex flex-col">
+        <CardHeader className="pb-4">
+          <div className="flex items-center justify-between">
+            <div className="flex items-center gap-2">
+              <CardTitle className="text-sm font-semibold">
+                {column.title}
+              </CardTitle>
+              <Badge 
+                variant="secondary" 
+                className={cn('text-xs px-2 py-1', getColumnColor(column.status))}
+              >
+                {column.tasks.length}
+                {column.maxTasks && ` / ${column.maxTasks}`}
+              </Badge>
+            </div>
+            
+            <Button
+              variant="ghost"
+              size="sm"
+              className="h-6 w-6 p-0"
+              onClick={() => onTaskAdd?.(column.id)}
+            >
+              <Plus className="h-3 w-3" />
+            </Button>
+          </div>
+        </CardHeader>
+        
+        <CardContent 
+          className={cn(
+            'flex-1 flex flex-col gap-3 transition-all duration-200 min-h-32 column-drop-zone relative',
+            draggedOver && 'drag-over bg-blue-50 border-2 border-dashed border-blue-300 scale-[1.01]'
+          )}
+          onDragOver={handleDragOver}
+          onDragEnter={handleDragEnter}
+          onDragLeave={handleDragLeave}
+          onDrop={handleDrop}
+        >
+          {column.tasks.length === 0 && (
+            <div className="flex-1 flex items-center justify-center text-muted-foreground text-sm">
+              No tasks
+            </div>
+          )}
+          
+          {column.tasks.map((task) => (
+            <div key={task.id} className="group">
+              <TaskCard
+                task={task}
+                onEdit={onTaskEdit}
+                onDelete={onTaskDelete}
+                onDragStart={onDragStart}
+                onDragEnd={onDragEnd}
+                isDragging={draggedTaskId === task.id}
+              />
+            </div>
+          ))}
+          
+          {draggedOver && column.tasks.length === 0 && (
+            <div className="h-20 border-2 border-dashed border-blue-300 rounded-lg bg-blue-50 flex items-center justify-center text-blue-600 text-sm animate-pulse">
+              <Plus className="h-4 w-4 mr-2" />
+              Drop task here
+            </div>
+          )}
+          
+          {draggedOver && column.tasks.length > 0 && (
+            <div className="h-2 border-t-2 border-dashed border-blue-400 bg-blue-100 rounded animate-pulse" />
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  )
+}
\ No newline at end of file
diff --git a/components/kanban/TaskCard.tsx b/components/kanban/TaskCard.tsx
new file mode 100644
index 0000000..9a6c178
--- /dev/null
+++ b/components/kanban/TaskCard.tsx
@@ -0,0 +1,155 @@
+'use client'
+
+import * as React from 'react'
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
+import { Badge } from '@/components/ui/badge'
+import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar'
+import { Button } from '@/components/ui/button'
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, DropdownMenuSeparator } from '@/components/ui/dropdown-menu'
+import { MoreVertical, Edit2, Trash2 } from 'lucide-react'
+import { cn } from '@/lib/utils'
+import { KanbanTask } from '@/types/kanban'
+
+interface TaskCardProps {
+  task: KanbanTask
+  onEdit?: (task: KanbanTask) => void
+  onDelete?: (taskId: string) => void
+  isDragging?: boolean
+  onDragStart?: (taskId: string) => void
+  onDragEnd?: () => void
+}
+
+export function TaskCard({ 
+  task, 
+  onEdit, 
+  onDelete, 
+  isDragging = false,
+  onDragStart,
+  onDragEnd
+}: TaskCardProps) {
+  const [dragState, setDragState] = React.useState<'idle' | 'dragging' | 'drag-over'>('idle')
+  const priorityColors = {
+    low: 'bg-green-100 text-green-800 hover:bg-green-200',
+    medium: 'bg-yellow-100 text-yellow-800 hover:bg-yellow-200',
+    high: 'bg-red-100 text-red-800 hover:bg-red-200'
+  }
+
+  const getInitials = (name: string) => {
+    return name
+      .split(' ')
+      .map(n => n[0])
+      .join('')
+      .toUpperCase()
+  }
+
+  const formatDate = (dateString: string) => {
+    return new Date(dateString).toLocaleDateString('en-US', {
+      month: 'short',
+      day: 'numeric'
+    })
+  }
+
+  const handleDragStart = (e: React.DragEvent) => {
+    e.dataTransfer.setData('text/plain', task.id)
+    e.dataTransfer.effectAllowed = 'move'
+    setDragState('dragging')
+    onDragStart?.(task.id)
+    
+    // Create a custom drag image
+    const dragImage = e.currentTarget.cloneNode(true) as HTMLElement
+    dragImage.style.transform = 'rotate(3deg)'
+    dragImage.style.opacity = '0.8'
+    document.body.appendChild(dragImage)
+    e.dataTransfer.setDragImage(dragImage, 50, 50)
+    
+    setTimeout(() => {
+      document.body.removeChild(dragImage)
+    }, 0)
+  }
+
+  const handleDragEnd = (e: React.DragEvent) => {
+    setDragState('idle')
+    onDragEnd?.()
+  }
+
+  return (
+    <Card 
+      className={cn(
+        'cursor-move transition-all duration-200 hover:shadow-md task-card select-none',
+        dragState === 'dragging' && 'opacity-30 scale-95',
+        isDragging && 'opacity-50 transform rotate-2'
+      )}
+      draggable
+      onDragStart={handleDragStart}
+      onDragEnd={handleDragEnd}
+    >
+      <CardHeader className="pb-2">
+        <div className="flex items-start justify-between">
+          <CardTitle className="text-sm font-medium leading-5">
+            {task.title}
+          </CardTitle>
+          <DropdownMenu>
+            <DropdownMenuTrigger asChild>
+              <Button
+                variant="ghost"
+                size="sm"
+                className="h-6 w-6 p-0 opacity-0 group-hover:opacity-100 transition-opacity"
+                onClick={(e) => e.preventDefault()}
+              >
+                <MoreVertical className="h-3 w-3" />
+              </Button>
+            </DropdownMenuTrigger>
+            <DropdownMenuContent align="end" className="w-36">
+              <DropdownMenuItem onClick={() => onEdit?.(task)}>
+                <Edit2 className="mr-2 h-3 w-3" />
+                Edit
+              </DropdownMenuItem>
+              <DropdownMenuSeparator />
+              <DropdownMenuItem 
+                onClick={() => onDelete?.(task.id)}
+                className="text-red-600 hover:text-red-700"
+              >
+                <Trash2 className="mr-2 h-3 w-3" />
+                Delete
+              </DropdownMenuItem>
+            </DropdownMenuContent>
+          </DropdownMenu>
+        </div>
+      </CardHeader>
+      
+      <CardContent className="pt-0">
+        {task.description && (
+          <p className="text-xs text-muted-foreground mb-3 line-clamp-2">
+            {task.description}
+          </p>
+        )}
+        
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-2">
+            <Badge 
+              variant="secondary" 
+              className={cn('text-xs px-2 py-0.5', priorityColors[task.priority])}
+            >
+              {task.priority}
+            </Badge>
+            
+            {task.dueDate && (
+              <span className="text-xs text-muted-foreground">
+                {formatDate(task.dueDate)}
+              </span>
+            )}
+          </div>
+          
+          {task.assignee && (
+            <Avatar className="h-5 w-5">
+              <AvatarImage src="" alt={task.assignee} />
+              <AvatarFallback className="text-xs">
+                {getInitials(task.assignee)}
+              </AvatarFallback>
+            </Avatar>
+          )}
+        </div>
+      </CardContent>
+    </Card>
+  )
+}
\ No newline at end of file
diff --git a/components/kanban/TaskModal.tsx b/components/kanban/TaskModal.tsx
new file mode 100644
index 0000000..232860f
--- /dev/null
+++ b/components/kanban/TaskModal.tsx
@@ -0,0 +1,255 @@
+'use client'
+
+import * as React from 'react'
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+import { Textarea } from '@/components/ui/textarea'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { KanbanTask } from '@/types/kanban'
+import { Calendar, CalendarDays, X } from 'lucide-react'
+
+interface TaskModalProps {
+  isOpen: boolean
+  onClose: () => void
+  onSave: (task: Partial<KanbanTask>) => void
+  task?: KanbanTask | null
+  mode: 'create' | 'edit'
+  columnId?: string
+  columnStatus?: 'todo' | 'in-progress' | 'done'
+}
+
+export function TaskModal({ 
+  isOpen, 
+  onClose, 
+  onSave, 
+  task, 
+  mode, 
+  columnId, 
+  columnStatus 
+}: TaskModalProps) {
+  const [formData, setFormData] = React.useState({
+    title: '',
+    description: '',
+    priority: 'medium' as 'low' | 'medium' | 'high',
+    assignee: '',
+    dueDate: ''
+  })
+
+  const [errors, setErrors] = React.useState<Record<string, string>>({})
+  const [isLoading, setIsLoading] = React.useState(false)
+
+  // Initialize form data when task or modal opens
+  React.useEffect(() => {
+    if (isOpen) {
+      if (mode === 'edit' && task) {
+        setFormData({
+          title: task.title,
+          description: task.description,
+          priority: task.priority,
+          assignee: task.assignee || '',
+          dueDate: task.dueDate ? new Date(task.dueDate).toISOString().split('T')[0] : ''
+        })
+      } else {
+        // Reset form for new task
+        setFormData({
+          title: '',
+          description: '',
+          priority: 'medium',
+          assignee: '',
+          dueDate: ''
+        })
+      }
+      setErrors({})
+    }
+  }, [isOpen, task, mode])
+
+  const validateForm = () => {
+    const newErrors: Record<string, string> = {}
+
+    if (!formData.title.trim()) {
+      newErrors.title = 'Title is required'
+    }
+
+    if (formData.title.length > 100) {
+      newErrors.title = 'Title must be less than 100 characters'
+    }
+
+    if (formData.description.length > 500) {
+      newErrors.description = 'Description must be less than 500 characters'
+    }
+
+    if (formData.assignee.length > 50) {
+      newErrors.assignee = 'Assignee name must be less than 50 characters'
+    }
+
+    if (formData.dueDate) {
+      const dueDate = new Date(formData.dueDate)
+      const today = new Date()
+      today.setHours(0, 0, 0, 0)
+      
+      if (dueDate < today) {
+        newErrors.dueDate = 'Due date cannot be in the past'
+      }
+    }
+
+    setErrors(newErrors)
+    return Object.keys(newErrors).length === 0
+  }
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    
+    if (!validateForm()) {
+      return
+    }
+
+    setIsLoading(true)
+    
+    try {
+      const taskData: Partial<KanbanTask> = {
+        ...formData,
+        dueDate: formData.dueDate ? new Date(formData.dueDate).toISOString() : undefined,
+        updatedAt: new Date().toISOString()
+      }
+
+      if (mode === 'create') {
+        taskData.id = `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+        taskData.status = columnStatus || 'todo'
+        taskData.createdAt = new Date().toISOString()
+      } else if (task) {
+        taskData.id = task.id
+        taskData.status = task.status
+        taskData.createdAt = task.createdAt
+      }
+
+      await onSave(taskData)
+      onClose()
+    } catch (error) {
+      console.error('Error saving task:', error)
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleInputChange = (field: string, value: string) => {
+    setFormData(prev => ({ ...prev, [field]: value }))
+    // Clear error when user starts typing
+    if (errors[field]) {
+      setErrors(prev => ({ ...prev, [field]: '' }))
+    }
+  }
+
+  return (
+    <Dialog open={isOpen} onOpenChange={onClose}>
+      <DialogContent className="sm:max-w-[525px]">
+        <DialogHeader>
+          <div className="flex items-center justify-between">
+            <DialogTitle>
+              {mode === 'create' ? 'Create New Task' : 'Edit Task'}
+            </DialogTitle>
+            <Button
+              variant="ghost"
+              size="sm"
+              className="h-6 w-6 p-0"
+              onClick={onClose}
+            >
+              <X className="h-4 w-4" />
+            </Button>
+          </div>
+        </DialogHeader>
+        
+        <form onSubmit={handleSubmit} className="space-y-4">
+          <div className="space-y-2">
+            <Label htmlFor="title">Title *</Label>
+            <Input
+              id="title"
+              value={formData.title}
+              onChange={(e) => handleInputChange('title', e.target.value)}
+              placeholder="Enter task title"
+              className={errors.title ? 'border-red-500' : ''}
+            />
+            {errors.title && (
+              <p className="text-sm text-red-500">{errors.title}</p>
+            )}
+          </div>
+
+          <div className="space-y-2">
+            <Label htmlFor="description">Description</Label>
+            <Textarea
+              id="description"
+              value={formData.description}
+              onChange={(e) => handleInputChange('description', e.target.value)}
+              placeholder="Enter task description"
+              rows={3}
+              className={errors.description ? 'border-red-500' : ''}
+            />
+            {errors.description && (
+              <p className="text-sm text-red-500">{errors.description}</p>
+            )}
+          </div>
+
+          <div className="grid grid-cols-2 gap-4">
+            <div className="space-y-2">
+              <Label htmlFor="priority">Priority</Label>
+              <Select 
+                value={formData.priority} 
+                onValueChange={(value) => handleInputChange('priority', value)}
+              >
+                <SelectTrigger>
+                  <SelectValue placeholder="Select priority" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="low">Low</SelectItem>
+                  <SelectItem value="medium">Medium</SelectItem>
+                  <SelectItem value="high">High</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div className="space-y-2">
+              <Label htmlFor="assignee">Assignee</Label>
+              <Input
+                id="assignee"
+                value={formData.assignee}
+                onChange={(e) => handleInputChange('assignee', e.target.value)}
+                placeholder="Assign to..."
+                className={errors.assignee ? 'border-red-500' : ''}
+              />
+              {errors.assignee && (
+                <p className="text-sm text-red-500">{errors.assignee}</p>
+              )}
+            </div>
+          </div>
+
+          <div className="space-y-2">
+            <Label htmlFor="dueDate">Due Date</Label>
+            <div className="relative">
+              <Input
+                id="dueDate"
+                type="date"
+                value={formData.dueDate}
+                onChange={(e) => handleInputChange('dueDate', e.target.value)}
+                className={errors.dueDate ? 'border-red-500' : ''}
+              />
+              <CalendarDays className="absolute right-3 top-2.5 h-4 w-4 text-muted-foreground pointer-events-none" />
+            </div>
+            {errors.dueDate && (
+              <p className="text-sm text-red-500">{errors.dueDate}</p>
+            )}
+          </div>
+
+          <DialogFooter>
+            <Button type="button" variant="outline" onClick={onClose}>
+              Cancel
+            </Button>
+            <Button type="submit" disabled={isLoading}>
+              {isLoading ? 'Saving...' : mode === 'create' ? 'Create Task' : 'Save Changes'}
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  )
+}
\ No newline at end of file
diff --git a/components/kanban/index.ts b/components/kanban/index.ts
new file mode 100644
index 0000000..97b34b6
--- /dev/null
+++ b/components/kanban/index.ts
@@ -0,0 +1,4 @@
+export { KanbanBoard } from './KanbanBoard'
+export { KanbanColumn } from './KanbanColumn'
+export { TaskCard } from './TaskCard'
+export { TaskModal } from './TaskModal'
\ No newline at end of file
diff --git a/components/kanban/kanban.css b/components/kanban/kanban.css
new file mode 100644
index 0000000..635ea24
--- /dev/null
+++ b/components/kanban/kanban.css
@@ -0,0 +1,158 @@
+/* Kanban Board Styles */
+.kanban-board {
+  @apply min-h-screen bg-background;
+}
+
+.kanban-scroll {
+  scrollbar-width: thin;
+  scrollbar-color: theme(colors.border) theme(colors.background);
+}
+
+.kanban-scroll::-webkit-scrollbar {
+  height: 8px;
+}
+
+.kanban-scroll::-webkit-scrollbar-track {
+  @apply bg-background rounded-lg;
+}
+
+.kanban-scroll::-webkit-scrollbar-thumb {
+  @apply bg-border rounded-lg;
+}
+
+.kanban-scroll::-webkit-scrollbar-thumb:hover {
+  @apply bg-muted-foreground/50;
+}
+
+/* Task Card Animations */
+.task-card {
+  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
+  user-select: none;
+}
+
+.task-card:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+}
+
+.task-card.dragging {
+  transform: rotate(3deg) scale(1.02);
+  opacity: 0.8;
+  z-index: 50;
+}
+
+/* Global dragging state */
+.kanban-board[data-dragging="true"] .task-card:not(.dragging) {
+  opacity: 0.6;
+  pointer-events: none;
+}
+
+.kanban-board[data-dragging="true"] .column-drop-zone {
+  background-color: rgba(59, 130, 246, 0.05);
+  border: 2px dashed rgba(59, 130, 246, 0.3);
+  transition: all 0.3s ease;
+}
+
+/* Column Drop Zone */
+.column-drop-zone {
+  transition: all 0.2s ease-in-out;
+}
+
+.column-drop-zone.drag-over {
+  @apply bg-blue-50 border-blue-300 scale-[1.02];
+}
+
+.column-drop-zone.drag-over::after {
+  content: '';
+  @apply absolute inset-0 bg-blue-100/50 rounded-lg;
+  animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite;
+}
+
+/* Priority Badges */
+.priority-low {
+  @apply bg-green-100 text-green-800 border-green-200;
+}
+
+.priority-medium {
+  @apply bg-yellow-100 text-yellow-800 border-yellow-200;
+}
+
+.priority-high {
+  @apply bg-red-100 text-red-800 border-red-200;
+}
+
+/* Column Status Colors */
+.status-todo {
+  @apply bg-slate-100 text-slate-700 border-slate-200;
+}
+
+.status-in-progress {
+  @apply bg-blue-100 text-blue-700 border-blue-200;
+}
+
+.status-done {
+  @apply bg-green-100 text-green-700 border-green-200;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+  .kanban-columns {
+    @apply gap-4;
+  }
+  
+  .kanban-column {
+    @apply min-w-72 max-w-72;
+  }
+  
+  .kanban-board-header {
+    @apply flex-col gap-4;
+  }
+}
+
+/* Text Truncation Utilities */
+.line-clamp-2 {
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
+
+.line-clamp-3 {
+  display: -webkit-box;
+  -webkit-line-clamp: 3;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
+
+/* Loading States */
+.kanban-skeleton {
+  @apply animate-pulse;
+}
+
+.kanban-skeleton .skeleton-text {
+  @apply bg-muted rounded h-4 w-full;
+}
+
+.kanban-skeleton .skeleton-text.short {
+  @apply w-3/4;
+}
+
+.kanban-skeleton .skeleton-avatar {
+  @apply bg-muted rounded-full h-6 w-6;
+}
+
+/* Focus Styles for Accessibility */
+.task-card:focus-visible {
+  @apply outline-2 outline-offset-2 outline-ring;
+}
+
+.column-header:focus-visible {
+  @apply outline-2 outline-offset-2 outline-ring;
+}
+
+/* Smooth Transitions */
+* {
+  transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter;
+  transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
+  transition-duration: 150ms;
+}
\ No newline at end of file
diff --git a/components/nav-main.tsx b/components/nav-main.tsx
index 3759bb8..ed984e4 100644
--- a/components/nav-main.tsx
+++ b/components/nav-main.tsx
@@ -1,5 +1,6 @@
 "use client"
 
+import Link from "next/link"
 import { IconCirclePlusFilled, IconMail, type Icon } from "@tabler/icons-react"
 
 import { Button } from "@/components/ui/button"
@@ -45,9 +46,11 @@ export function NavMain({
         <SidebarMenu>
           {items.map((item) => (
             <SidebarMenuItem key={item.title}>
-              <SidebarMenuButton tooltip={item.title}>
-                {item.icon && <item.icon />}
-                <span>{item.title}</span>
+              <SidebarMenuButton tooltip={item.title} asChild>
+                <Link href={item.url}>
+                  {item.icon && <item.icon />}
+                  <span>{item.title}</span>
+                </Link>
               </SidebarMenuButton>
             </SidebarMenuItem>
           ))}
diff --git a/documentation/app_flow_document.md b/documentation/app_flow_document.md
index 1916d04..518f485 100644
--- a/documentation/app_flow_document.md
+++ b/documentation/app_flow_document.md
@@ -2,40 +2,28 @@
 
 ## Onboarding and Sign-In/Sign-Up
 
-When a new visitor arrives at the application’s root URL, they land on a welcome page that offers clear buttons or links to either create an account or sign in. Clicking on the “Sign Up” link takes the visitor to a registration page where they enter their email address and choose a password. Once they submit the form, the application sends a POST request to the authentication API endpoint, which handles password hashing and user creation. If registration succeeds, the new user is automatically signed in and redirected to the dashboard. If there are validation errors, such as a password that is too short or an email already in use, the form reappears with inline messages explaining what must be corrected.
+When a brand-new visitor opens the application in a browser, they arrive at the root URL, where the global layout displays the site name and navigation links labeled “Sign In” and “Sign Up.” Clicking “Sign Up” takes the user to the sign-up page. A simple form appears asking for an email address and a password. When the user fills in these fields and submits the form, the application sends the information to the authentication endpoint at `/api/auth/route`. If everything is valid, the user is automatically logged in and redirected to the dashboard. If there is an error, an inline message appears above the form explaining what went wrong, and the user can correct the input.
 
-For returning users, clicking the “Sign In” link from the welcome page or from a persistent header link opens the login form. They input their email and password, and upon submission the app sends a request to the same authentication API with login credentials. A successful login leads directly to the dashboard. If the credentials are invalid, the page reloads with a clear error message prompting the user to try again.
-
-Signing out is available from within the dashboard via a logout button in the main navigation or header. When clicked, the application clears the user’s session or token, and then navigates back to the welcome page. Currently, there is no built-in password recovery or reset flow in this version, so users who forget their password are prompted to contact support for assistance.
+Returning visitors click “Sign In” in the navigation. They are taken to a page with a login form that again asks for email and password. After entering credentials and submitting, the application sends a POST request to the same `/api/auth/route` endpoint. On success, the user session is established and the user is sent to the main dashboard. If the credentials are incorrect, an error message appears and the user stays on the sign-in page until valid details are entered. There is no separate forgot password flow in the current version, so users must contact support or retry with known credentials. Signing out is available after login through a link labeled “Sign Out” in the header, which clears the session and returns the user to the sign-in page.
 
 ## Main Dashboard or Home Page
 
-After authentication, the user lands on the dashboard, which serves as the main home page. The dashboard is wrapped in a layout that displays a header bar and a sidebar navigation tailored for logged-in users. The header bar typically shows the application’s logo on the left and a Logout link on the right. The sidebar sits on the left side of the screen and may contain links back to the dashboard’s main panel or to future features.
-
-The central area of the dashboard page displays data pulled from a static JSON file. This content might appear in cards or tables to give users a quick overview of information. All styling for this section comes from a dedicated theme stylesheet to keep the look consistent. Users can click items or links here, but those actions are placeholders for future dynamic data features.
-
-From this dashboard view, users may revisit the welcome page or any other main area by selecting navigation items in the sidebar or header. The layout ensures that the logout link remains accessible at all times, and that the user cannot leave the authenticated area without signing out manually or having their session expire.
+Once authenticated, the user lands on the dashboard at `/dashboard`. The global layout still wraps the view, providing the site header and the “Sign Out” link, and the dashboard layout adds a sidebar or top navigation bar specific to the dashboard. This dashboard interface shows data pulled from a local `data.json` file, such as lists of items or summary metrics. The header area may display the user’s email or name. From this main view, the user can click any sidebar label or header link to navigate to other parts of the dashboard or return to the sign-in or sign-up pages if they have been logged out.
 
 ## Detailed Feature Flows and Page Transitions
 
-When a visitor lands on the root page, JavaScript on the client reads the route and displays either the welcome interface or automatically redirects them to the dashboard if a valid session exists. For new user registration, the user clicks the Sign Up link and is taken to the sign-up page. The sign-up form collects email and password fields, and on submission it triggers a client-side POST to the API route. Once the API responds with success, the client redirects the user to the dashboard page.
+When the user chooses to sign up, the page transition goes from the root layout to the sign-up page. The sign-up form collects the user’s email and password and then calls the API to create a new account. After a successful response, the application programmatically navigates to the dashboard route. If the user instead goes to sign in, the transition is the same but the form action is interpreted as authentication rather than account creation. Once the user is on the dashboard, clicking the site logo or a “Home” link in the dashboard navigation returns them to the dashboard main view. Attempting to access `/dashboard` directly in the URL bar while not signed in triggers a redirect back to `/sign-in`, enforcing protection.
 
-Returning users choose the Sign In link and arrive at the sign-in page, which offers the same fields as the sign-up page but is wired to authenticate rather than create a new account. On form submit, the user sees a loading indication until the API confirms valid credentials. If successful, the client pushes the dashboard route and loads the dashboard layout and content.
-
-All authenticated pages reside under the `/dashboard` path. When the user attempts to navigate directly to `/dashboard` without a valid session, server-side redirection logic intercepts the request and sends the user back to the sign-in page. This ensures that protected content never shows to unauthorized visitors.
-
-Signing out happens entirely on the client side by calling an API or clearing a cookie, then navigating back to the welcome page. The client code listens for the logout action, invalidates the current session, and then reloads or reroutes the application state to the landing interface.
+On the dashboard itself, any link or button that takes the user outside of this section is handled by the root layout, which may navigate back to the sign-in or sign-up pages. When the user clicks “Sign Out,” the application calls a sign-out function that clears the session on the client and possibly invalidates a cookie, then routes the user to the sign-in page. Every page transition uses the framework’s file-based routing under the `app` directory, so the URL path always matches the folder and file where the code lives.
 
 ## Settings and Account Management
 
-At present, users cannot change profile information, update their email, or configure notifications from within the interface. The only account management available is the ability to sign out from any dashboard view. In future iterations, a dedicated settings page could be added to let users update personal details or adjust preferences, but in this version, those capabilities are not provided. After signing out, users always return to the welcome page and must sign in again to regain access to the dashboard.
+In the current version, there is no dedicated settings or profile page for managing personal details beyond email and password at sign-up. The primary account management action is signing out, which the user finds in the global header. Future versions may include a profile page under `/profile` or `/settings` where users can update their information, configure notification preferences, or manage subscriptions. At present, any change to preferences or account details would require updating code or database records externally, as there is no UI for it.
 
 ## Error States and Alternate Paths
 
-If a user types an incorrect email or password on the sign-in page, the authentication API responds with an error status and a message. The form then displays an inline alert near the input fields explaining the issue, such as “Invalid email or password,” allowing the user to correct and resubmit. During sign up, validation errors like a missing field or weak password appear immediately under the relevant input.
-
-Network failures trigger a generic error notification at the top of the form, informing the user that the request could not be completed and advising them to check their connection. If the dashboard content fails to load due to a broken or missing static data file, a fallback message appears in the main panel stating that data could not be loaded and suggesting a page refresh. Trying to access a protected route without a session sends the user to the sign-in page automatically, making it clear that authentication is required.
+If the user enters invalid data on sign-up or sign-in, the form validation runs on the client and the server. Errors such as missing fields, improperly formatted email, or weak password are caught and displayed above the form. If the network connection fails during an API call, a generic message prompts the user to check their connection and try again. When an unauthenticated user attempts to view a protected page, the application automatically redirects to the sign-in page with no warning popup, preserving security. Unexpected server errors return a generic error view or message, and the user can retry the action or refresh the page to recover.
 
 ## Conclusion and Overall App Journey
 
-A typical user journey starts with visiting the application’s root URL, signing up with an email and password, then being welcomed in the dashboard area that displays sample data. Returning users go directly through the sign-in page to the dashboard. Throughout each step, clear messages guide the user in case of errors or invalid input. The layout remains consistent, with a header and navigation ensuring that users always know where they are and can sign out at any time. This flow lays the foundation for adding dynamic data, user profile management, and richer features in future releases.
\ No newline at end of file
+From the moment a new user discovers the application at its root URL, they can create an account or log in with just an email and password. After authentication, they land on a clean dashboard interface that uses mock data to illustrate how real content will appear. Navigation is intuitive through links in the global header and dashboard layout, and signing out is always one click away. Error messages guide the user through any mistakes, and unauthorized access is blocked automatically. In everyday use, the goal is to sign in, review or interact with dashboard data, and sign out when finished, providing a smooth and predictable journey from start to finish.
\ No newline at end of file
diff --git a/documentation/app_flowchart.md b/documentation/app_flowchart.md
index 8460af1..fcff11c 100644
--- a/documentation/app_flowchart.md
+++ b/documentation/app_flowchart.md
@@ -1,14 +1,15 @@
 flowchart TD
-  Start[Landing Page]
-  SignUpPage[Sign Up Page]
-  SignInPage[Sign In Page]
-  AuthAPI[Authentication API Endpoint]
-  DashboardPage[Dashboard Page]
-  Start -->|Select Sign Up| SignUpPage
-  Start -->|Select Sign In| SignInPage
-  SignUpPage -->|Submit Credentials| AuthAPI
-  SignInPage -->|Submit Credentials| AuthAPI
-  AuthAPI -->|Success| DashboardPage
-  AuthAPI -->|Error| SignUpPage
-  AuthAPI -->|Error| SignInPage
-  DashboardPage -->|Click Logout| Start
\ No newline at end of file
+A[Visit Root URL] --> B{User Authenticated}
+B -->|No| C[Show Sign In and Sign Up Links]
+B -->|Yes| D[Redirect to Dashboard]
+C --> E[Sign In Page]
+C --> F[Sign Up Page]
+E --> G[Submit Credentials to Auth Endpoint]
+F --> G
+G --> H{Auth Success}
+H -->|Yes| D
+H -->|No| I[Show Error Message]
+I --> C
+D --> J[Dashboard Page]
+J --> K[Click Sign Out]
+K --> B
\ No newline at end of file
diff --git a/documentation/backend_structure_document.md b/documentation/backend_structure_document.md
index 1ea043b..85231c8 100644
--- a/documentation/backend_structure_document.md
+++ b/documentation/backend_structure_document.md
@@ -1,179 +1,143 @@
 # Backend Structure Document
 
-This document outlines the backend architecture, hosting, and infrastructure for the **codeguide-starter** project. It uses plain language so anyone can understand how the backend is set up and how it supports the application.
+This document explains how the backend of the `codeguide-starter-fullstack` project is organized, hosted, and maintained. It’s written in plain language so anyone can understand how the pieces fit together and why they were chosen.
 
 ## 1. Backend Architecture
 
-- **Framework and Design Pattern**
-  - We use **Next.js API Routes** to handle all server-side logic. These routes live alongside the frontend code in the same repository, making development and deployment simpler.
-  - The backend follows a **layered pattern**:
-    1. **API Layer**: Receives requests (login, registration, data fetch).  
-    2. **Service Layer**: Contains the core business logic (user validation, password hashing).  
-    3. **Data Access Layer**: Talks to the database via a simple ORM (e.g., Prisma or TypeORM).
+### Overall Design
+- We use Next.js’s built-in API Routes to handle server-side work. Each file under `app/api/` becomes a serverless function.  
+- The backend lives in the same codebase as the frontend, sharing TypeScript types and folder structure.  
+- File-based routing means the folder structure directly maps to URL paths, so there’s no separate routing config.
 
-- **Scalability**
-  - Stateless API routes can scale horizontally—new instances can spin up on demand.  
-  - We can add caching or a message queue (e.g., Redis or RabbitMQ) without changing the core code.
+### Frameworks and Patterns
+- **Next.js API Routes**: Server‐side endpoints written in TypeScript.  
+- **Node.js**: Under the hood, those API routes run on a Node.js environment (v16+).  
+- **Component-Driven**: Business logic is split into small functions that can be re-used by different routes.
 
-- **Maintainability**
-  - Code for each feature is grouped by route (authentication, dashboard).  
-  - A service layer separates complex logic from request handling.
-
-- **Performance**
-  - Lightweight Node.js handlers keep response times low.  
-  - Future use of database connection pooling and Redis for caching repeated queries.
+### Scalability, Maintainability, Performance
+- **Scalability**: Serverless functions auto-scale with demand—no need to manage servers.  
+- **Maintainability**: Keeping backend code next to frontend code simplifies sharing types and utilities.  
+- **Performance**: Next.js pre-optimizes routes and cold starts are minimized on platforms like Vercel.
 
 ## 2. Database Management
 
-- **Database Choice**
-  - We recommend **PostgreSQL** for structured data and reliable transactions.  
-  - In-memory caching can be added later with **Redis** for session tokens or frequently read data.
+### Current Setup (Mock Data)
+- We use a local JSON file (`data.json`) as a stand-in for a real database during development.  
+- This file lives in the repo and contains an array of objects representing dashboard items.
 
-- **Data Storage and Access**
-  - Use an ORM like **Prisma** or **TypeORM** to map JavaScript/TypeScript objects to database tables.
-  - Connection pooling ensures efficient use of database connections under load.
-  - Migrations track schema changes over time, keeping development, staging, and production in sync.
+### Future Database Options
+- When migrating to a real database, you could choose:
+  - **SQL (PostgreSQL, MySQL)** for structured, relational data.  
+  - **NoSQL (MongoDB, DynamoDB)** for flexible, document-oriented storage.
 
-- **Data Practices**
-  - Passwords are never stored in plain text—they are salted and hashed with **bcrypt** before saving.
-  - All outgoing data is typed and validated to prevent malformed records.
+### Data Access
+- In the mock version, API routes read `data.json` directly.  
+- In a real setup, you’d replace that read with a database query using an ORM like Prisma or a driver like `pg`.
 
 ## 3. Database Schema
 
-### Human-Readable Format
-
-- **Users**
-  - **id**: Unique identifier  
-  - **email**: User’s email address (unique)  
-  - **password_hash**: Securely hashed password  
-  - **created_at**: Account creation timestamp
+### Mock Data (`data.json`)
+The JSON file holds an array of dashboard items. Each item has:
+- **id** (string): Unique identifier.  
+- **title** (string): Name of the item or metric.  
+- **value** (number): Numeric data to display.  
+- **details** (string): Optional description or extra info.
 
-- **Sessions**
-  - **id**: Unique session record  
-  - **user_id**: Links to a user  
-  - **token**: Random string for authentication  
-  - **expires_at**: When the token stops working  
-  - **created_at**: When the session was created
+Example in everyday terms:
+- Item 1: id = "item1", title = "Total Users", value = 1024, details = "Count of all registered users"  
+- Item 2: id = "item2", title = "Active Sessions", value = 87, details = "Users currently online"
 
-- **DashboardItems** *(optional for dynamic data)*
-  - **id**: Unique record  
-  - **title**: Item title  
-  - **content**: Item details  
-  - **created_at**: When the item was added
-
-### SQL Schema (PostgreSQL)
+### (Future) SQL Schema Example
+If you switch to PostgreSQL, your `dashboard_items` table might look like:
 ```sql
--- Users table
-CREATE TABLE users (
-  id SERIAL PRIMARY KEY,
-  email VARCHAR(255) UNIQUE NOT NULL,
-  password_hash VARCHAR(255) NOT NULL,
-  created_at TIMESTAMPTZ DEFAULT now()
-);
-
--- Sessions table
-CREATE TABLE sessions (
-  id SERIAL PRIMARY KEY,
-  user_id INT REFERENCES users(id) ON DELETE CASCADE,
-  token VARCHAR(255) UNIQUE NOT NULL,
-  expires_at TIMESTAMPTZ NOT NULL,
-  created_at TIMESTAMPTZ DEFAULT now()
-);
-
--- Dashboard items table
 CREATE TABLE dashboard_items (
-  id SERIAL PRIMARY KEY,
+  id TEXT PRIMARY KEY,
   title TEXT NOT NULL,
-  content TEXT,
-  created_at TIMESTAMPTZ DEFAULT now()
+  value INTEGER NOT NULL,
+  details TEXT
 );
-```  
+```
 
 ## 4. API Design and Endpoints
 
-- **Approach**: We follow a **RESTful** style, grouping related endpoints under `/api` directories.
-
-- **Key Endpoints**
-  - `POST /api/auth/register`  
-    • Accepts `{ email, password }`  
-    • Creates a new user and issues a session token  
-  - `POST /api/auth/login`  
-    • Accepts `{ email, password }`  
-    • Verifies credentials and returns a session token  
-  - `POST /api/auth/logout`  
-    • Invalidates the session token on the server  
-  - `GET /api/dashboard/data`  
-    • Requires a valid session  
-    • Returns user-specific data or dashboard items  
-
-- **Communication**
-  - Frontend sends JSON requests; backend replies with JSON and appropriate HTTP status codes.  
-  - Protected routes check for a valid session token (in cookies or Authorization header).
+We follow a simple RESTful style using Next.js API Routes.
 
-## 5. Hosting Solutions
+### Key Endpoints
+- **POST /api/auth**  
+  - Purpose: Sign up or sign in a user.  
+  - Input: `{ email: string, password: string }`  
+  - Output: Success status, user session or error message.
 
-- **Cloud Provider**:  
-  - **Vercel** (recommended) offers seamless Next.js deployments, auto-scaling, and built-in CDN.  
-  - Alternatively, **Netlify** or any Node.js-capable host will work.
+- **GET /api/data** (optional)  
+  - Purpose: Fetch mock dashboard items from `data.json`.  
+  - Output: Array of items.
 
-- **Benefits**
-  - **Reliability**: Global servers and failover across regions.  
-  - **Scalability**: Auto-scale serverless functions based on traffic.  
-  - **Cost-Effectiveness**: Pay-per-use model means low cost for small projects.
+### How Frontend Calls These
+1. Sign-in form submits credentials to `/api/auth`.  
+2. On success, Next.js sets a session cookie and redirects to `/dashboard`.  
+3. Dashboard page fetches `/api/data` to display items.
 
-## 6. Infrastructure Components
+## 5. Hosting Solutions
 
-- **Load Balancer**
-  - Provided by the hosting platform—distributes API requests across function instances.
+### Chosen Platform: Vercel
+- **Why Vercel?**  
+  - Built by the creators of Next.js—seamless integration.  
+  - Automatic global CDN for static assets.  
+  - Serverless functions run our API Routes without setup.
 
-- **CDN (Content Delivery Network)**
-  - Vercel’s global edge network caches static assets (CSS, JS, images) for faster page loads.
+### Benefits
+- **Reliability**: Automatic health checks and rollbacks.  
+- **Scalability**: Instantly scales serverless functions with traffic.  
+- **Cost-Effective**: Free tier available; pay only for extra usage.
 
-- **Caching**
-  - **Redis** (optional) for session storage or caching dashboard queries to reduce database load.
+## 6. Infrastructure Components
 
-- **Object Storage**
-  - For file uploads or backups, integrate with AWS S3 or similar services.
+### Load Balancing and CDN
+- Vercel uses its edge network to distribute traffic across regions.  
+- Static files (CSS, images) served from a CDN close to users.
 
-- **Message Queue**
-  - In future, use **RabbitMQ** or **Kafka** for background tasks (e.g., email notifications).
+### Caching Mechanisms
+- **ISR (Incremental Static Regeneration)** in Next.js can cache pages and update them in the background.  
+- **HTTP Caching** headers can be configured for API responses.
 
-## 7. Security Measures
+### Content Delivery Networks
+- All static assets are automatically uploaded and distributed by Vercel’s CDN.
 
-- **Authentication & Authorization**
-  - Passwords hashed with **bcrypt** and salted.  
-  - Session tokens stored in secure, HttpOnly cookies or Authorization headers.  
-  - Protected endpoints verify tokens before proceeding.
+## 7. Security Measures
 
-- **Data Encryption**
-  - **HTTPS/TLS** encrypts data in transit.  
-  - Database connections use SSL to encrypt data between the app and the database.
+### Authentication & Authorization
+- **Secure Cookies**: Session tokens are stored in HTTP-only cookies to prevent JavaScript access.  
+- **Password Handling**: Even in mock mode, follow best practice by hashing passwords with a library like `bcrypt`.
 
-- **Input Validation**
-  - Every incoming request is validated (e.g., valid email format, password length) to prevent SQL injection or other attacks.
+### Data Protection
+- **Input Validation**: Check and sanitize all incoming data on the server.  
+- **Redirect Protection**: Unauthenticated users are sent back to `/sign-in` if they try to access protected routes.
 
-- **Web Security Best Practices**
-  - Enable **CORS** policies to limit allowed origins.  
-  - Use **CSRF tokens** or same-site cookies to prevent cross-site requests.  
-  - Set secure headers with **Helmet** or a similar middleware.
+### Compliance and Best Practices
+- Plan for GDPR by ensuring user data can be erased or exported upon request.  
+- Prepare to add CSRF tokens if you introduce cookie-based sessions in production.
 
 ## 8. Monitoring and Maintenance
 
-- **Performance Monitoring**
-  - Integrate **Sentry** or **LogRocket** for real-time crash reporting and performance tracing.  
-  - Use Vercel’s built-in analytics to track request latencies and error rates.
-
-- **Logging**
-  - Structured logs (JSON) for all API requests and errors, shipped to a log management service like **Datadog** or **Logflare**.
+### Performance Monitoring
+- **Vercel Analytics**: Built-in metrics for response times, cold starts, and bandwidth.  
+- **Optional Tools**: Integrate Sentry or Datadog to track errors and performance events in more detail.
 
-- **Health Checks**
-  - Define a `/health` endpoint that returns a 200 status if the service is up and the database is reachable.
+### Logging
+- Use `console.log` in development; in production, route logs to a service like Logflare or Datadog.
 
-- **Maintenance Strategies**
-  - Automated migrations run on deploy to keep the database schema up to date.  
-  - Scheduled dependency audits and security scans (e.g., `npm audit`).
-  - Regular backups of the database (daily or weekly depending on usage).
+### Maintenance Strategies
+- **Automated Tests**: Run linting and basic API tests via GitHub Actions on every pull request.  
+- **Dependency Updates**: Schedule regular checks (Dependabot) and use `npm audit` to identify vulnerabilities.  
+- **Backups**: If you adopt a real database, set up automated backups (e.g., daily snapshots on PostgreSQL).
 
 ## 9. Conclusion and Overall Backend Summary
 
-The backend for **codeguide-starter** is built on Next.js API Routes and Node.js, paired with PostgreSQL for data and optional Redis for caching. It follows a clear layered architecture that keeps code easy to maintain and extend. With RESTful endpoints for authentication and data, secure practices like password hashing and HTTPS, and hosting on Vercel for scalability and global performance, this setup meets the project’s goals for a fast, secure, and developer-friendly foundation. Future enhancements—such as background job queues, advanced monitoring, or richer data models—can be added without disrupting the core structure.
\ No newline at end of file
+This backend uses Next.js API Routes and a local JSON file as a quick, zero-config starting point. It lives next to the frontend for shared types and easy deployment. Hosted on Vercel, it scales seamlessly without manual server management. Key highlights:
+
+- **Serverless Architecture**: No servers to maintain—functions scale automatically.  
+- **Local Mock Database**: Simplifies development; ready to swap to SQL or NoSQL.  
+- **Secure by Default**: HTTP-only cookies and input checks protect user data.  
+- **Easy Monitoring**: Vercel Analytics plus optional Sentry/Datadog integrations.
+
+As your project grows, you can replace the mock data with a real database, integrate third-party services, and expand the API surface—all without changing the underlying structure. This setup gives you a clear path from prototype to production.
\ No newline at end of file
diff --git a/documentation/frontend_guidelines_document.md b/documentation/frontend_guidelines_document.md
index ffa3ea5..f71bd10 100644
--- a/documentation/frontend_guidelines_document.md
+++ b/documentation/frontend_guidelines_document.md
@@ -1,180 +1,168 @@
 # Frontend Guideline Document
 
-This document explains, in simple terms, how the frontend of the `codeguide-starter` project is structured, styled, and built. Anyone—technical or not—can read this and understand which tools are used, how components fit together, and what practices keep the app fast, reliable, and easy to maintain.
+This document explains the frontend setup for the `codeguide-starter-fullstack` project in clear, everyday language. It covers architecture, design principles, styling, component organization, state handling, routing, performance, and testing practices.
 
 ---
 
 ## 1. Frontend Architecture
 
-**Core Frameworks and Libraries**
-- **Next.js (App Router)**: A React-based framework that provides file-based routing, server-side rendering (SSR), static site generation (SSG), and built-in API endpoints all in one project.
-- **React 18**: The library for building user interfaces using components and hooks.
-- **TypeScript**: A superset of JavaScript that adds static types, helping catch errors early and making the code easier to understand and refactor.
-
-**How It’s Organized**
-- The `app/` folder holds all pages and layouts. Each URL path corresponds to a folder:
-  - `/app/sign-in` and `/app/sign-up` for authentication pages.
-  - `/app/dashboard` for the protected user area.
-  - API routes live under `/app/api/auth/route.ts`.
-- Each route folder contains:
-  - `page.tsx` (the UI for that page)
-  - `layout.tsx` (wrapping structure, like headers or sidebars)
-  - Styles (e.g., `theme.css` in the dashboard).
-
-**Why This Works**
-- **Scalability**: Adding new pages or features means creating new folders with their own layouts and pages. You don’t have to touch a central router file.
-- **Maintainability**: Code is separated by feature. Backend logic (API routes) lives alongside the frontend code for that feature, reducing context-switching.
-- **Performance**: Next.js pre-renders pages where possible and splits code by route, so users download only what’s needed.
+**Frameworks and Libraries**
+- **Next.js 13** (or Remix): Provides file-based routing, built-in API routes, and support for server-side rendering (SSR) and static site generation (SSG).
+- **React 18**: The UI library that lets us build reusable components.
+- **TypeScript**: Adds type safety to catch errors early and make the code easier to understand.
+- **CSS**: We use plain CSS files (`globals.css` and `theme.css`) with CSS custom properties for theming.
+
+**How It Supports Scalability, Maintainability, and Performance**
+- **File-based routing** means each folder and file under `app/` maps directly to a URL path. Adding a new page is as easy as creating a new file.
+- **Nested layouts** (`app/layout.tsx` and `app/dashboard/layout.tsx`) allow us to share headers, footers, and sidebars without repeating code.
+- **Component-based structure** (React) promotes reuse: build small, focused pieces that can be combined in different ways.
+- **TypeScript and linting** (ESLint & Prettier) ensure consistent code style, fewer runtime errors, and easier onboarding for new developers.
+- **SSR/SSG** speeds up initial page loads and improves SEO out of the box.
 
 ---
 
 ## 2. Design Principles
 
-1. **Usability**: Forms give instant feedback. Buttons and links are clearly labeled.
-2. **Accessibility**: Semantic HTML, proper color contrast, and focus outlines ensure people using screen readers or keyboards can navigate easily.
-3. **Responsiveness**: Layouts adapt from mobile (320px) up to large desktop screens. CSS media queries ensure content resizes and stacks neatly.
-4. **Consistency**: Shared global layout and styling mean pages look and feel like part of the same app.
-
-**How We Apply Them**
-- Form fields use `aria-*` attributes and visible labels.
-- Error messages appear inline under inputs.
-- Navigation elements (header, sidebar) appear in every layout.
-- Breakpoints at 480px, 768px, and 1024px guide responsive adjustments.
+We follow these guiding principles to create a user-friendly interface:
+
+1. **Usability**
+   - Simple, predictable navigation.
+   - Clear calls to action (e.g., “Sign In,” “Sign Up,” “Sign Out”).
+2. **Accessibility**
+   - Semantic HTML elements (forms, buttons, headings).
+   - ARIA attributes and keyboard support for screen readers.
+3. **Responsiveness**
+   - Mobile-first CSS breakpoints.
+   - Flexible layouts that adapt to different screen sizes.
+4. **Consistency**
+   - Uniform color scheme and typography across all pages.
+   - Reusable component styles to avoid visual drift.
+
+How We Apply These
+- Forms on sign-in and sign-up pages include error messages and focus management for keyboard navigation.
+- The dashboard layout uses clear headings and side navigation that collapse gracefully on smaller screens.
+- All interactive elements (links, buttons) have hover/focus styles for better discoverability.
 
 ---
 
 ## 3. Styling and Theming
 
-**Approach**
-- **Global Styles (`globals.css`)**: Resets, base typography, and common utility classes.
-- **Section Styles (`theme.css` in dashboard)**: Styles specific to the dashboard area (colors, layouts).
-- We follow a **BEM-inspired naming** for classes when writing new CSS to avoid conflicts and keep selectors clear.
-
-**Visual Style**: Modern flat design with subtle shadows for depth. Clear spacing and large touch targets on mobile.
-
-**Color Palette**
-- **Primary Blue**: #1E90FF  (buttons, highlights)
-- **Secondary Navy**: #2C3E50  (header, sidebar background)
-- **Accent Cyan**: #00CEC9  (links, hover states)
-- **Neutral Light**: #F8F9FA  (page backgrounds)
-- **Neutral Dark**: #2D3436  (text, icons)
-
-**Font**
-- **Inter** (sans-serif): Clean, modern, highly legible on screens. Fallback to system fonts like `-apple-system, BlinkMacSystemFont, sans-serif`.
+**Styling Approach**
+- **CSS files**: We have two main files:
+  1. `globals.css` – Base styles for typography, layout resets, and utility classes.
+  2. `theme.css` – CSS custom properties (variables) defining the color palette and spacing scales.
+- **CSS Methodology**: We adopt a simple, modular approach:
+  - Use descriptive class names in **BEM** style (e.g., `.button`, `.button--primary`).
+  - Keep component styles close to their markup in dedicated `.css` files if needed.
 
 **Theming**
-- To keep a consistent look, all colors and font sizes are defined in CSS variables in `globals.css`:
-  ```css
-  :root {
-    --color-primary: #1E90FF;
-    --color-secondary: #2C3E50;
-    --color-accent: #00CEC9;
-    --color-bg: #F8F9FA;
-    --color-text: #2D3436;
-    --font-family: 'Inter', sans-serif;
-  }
-  ```
-- Components consume these variables for backgrounds, borders, and text.
+- All colors and fonts are defined as CSS variables in `theme.css`.
+- Switching themes (e.g., light/dark) is a matter of toggling a single class on `<html>` or `<body>`.
+
+**Visual Style**
+- **Overall Style**: Flat, modern design with generous white space and clear typography.
+- **Color Palette**:
+  - `--color-primary`: #4F46E5 (indigo)
+  - `--color-secondary`: #10B981 (emerald)
+  - `--color-accent`: #F59E0B (amber)
+  - `--color-background`: #F9FAFB (light gray)
+  - `--color-surface`: #FFFFFF (white)
+  - `--color-border`: #E5E7EB (gray)
+  - `--color-text`: #111827 (dark gray)
+  - `--color-text-muted`: #6B7280 (mid gray)
+- **Typography**:
+  - Primary font: **Inter**, with system-font fallbacks (`-apple-system, BlinkMacSystemFont, sans-serif`).
+  - Base font size: 16px; line height: 1.5; clear hierarchy with `h1`–`h4` sizing.
 
 ---
 
 ## 4. Component Structure
 
-**File Layout**
-- `/app` (top-level folder)
-  - `layout.tsx`: Global wrapper (nav, footer).
-  - `page.tsx`: Landing or redirect logic.
-  - `/sign-in`, `/sign-up`, `/dashboard`, `/api/auth`
-    - Each has its own `layout.tsx` and `page.tsx`.
-- **Common Components**: Put reusable UI pieces (buttons, inputs, cards) into a `/components` folder at the project root.
+**Organization**
+- **Feature-based folders** under `app/` for pages and layouts (`dashboard/`, `sign-in/`, `sign-up/`).
+- A top-level **`components/`** directory for shared UI elements (e.g., Button, Input, Card).
+- Each component has:
+  - A `.tsx` file for markup and logic.
+  - A `.module.css` or scoped CSS file for styles (if more CSS is needed beyond the global/theme).  
 
-**Reusability & Encapsulation**
-- Components are self-contained: each has its own styles (class names scoped to BEM) and behavior.
-- Shared logic (e.g., API calls) lives in `/lib` or `/hooks` so pages import only what they need.
-
-**Benefits**
-- **Easier Maintenance**: Fix a bug in one button component, and it updates everywhere.
-- **Better Team Collaboration**: Developers can own specific components or pages without stepping on each other’s code.
+**Reusability and Maintainability**
+- Components are **small and focused**: one responsibility each (e.g., a Button that accepts props for label and click handler).
+- **Props** are well-typed with TypeScript interfaces for clarity.
+- **Documentation** is encouraged: add brief comments or Storybook stories (if integrated) to show usage examples.
 
 ---
 
 ## 5. State Management
 
-**Current Approach**
-- **Local State**: React `useState` and `useEffect` for form values, loading flags, and error messages.
-- **Server State**: Fetch data (e.g., dashboard JSON) directly in page components or using React Server Components.
-
-**Sharing State**
-- **React Context**: A simple auth context (`AuthContext`) holds the user’s session info, login/logout methods, and makes it available to any component.
-  - Located in `/context/AuthContext.tsx`.
+**Approach**
+- **Local state** with `useState` for simple UI interactions.
+- **Global state** (e.g., authenticated user info) via React **Context API**:
+  - Create an `AuthContext` to hold user data and helper methods (`signIn`, `signOut`).
+  - Wrap the app in an `AuthProvider` in `app/layout.tsx` so all pages can access it.
 
-**Future Growth**
-- If complexity grows (deeply nested data, multiple user roles), consider:
-  - **Redux Toolkit** or **Zustand** for centralized state.
-  - Query libraries like **React Query** or **SWR** for caching and re-fetch logic.
+**Sharing State Across Components**
+- Components subscribe to context values via `useContext(AuthContext)`.
+- For data fetching (dashboard content), keep local state or introduce **React Query** (or SWR) in the next phase to handle caching, loading, and error states.
 
 ---
 
 ## 6. Routing and Navigation
 
-**Routing Library**
-- Built into **Next.js App Router**. Each folder under `/app` becomes a route automatically.
-- Layouts (`layout.tsx`) and pages (`page.tsx`) are colocated for that route.
-
-**Protected Pages**
-- The dashboard’s `layout.tsx` checks for a valid session (via cookie or context). If missing, it issues a server-side redirect to `/sign-in`.
+**Routing**
+- **File-based routing** in Next.js (`app/` folder):
+  - A file `app/dashboard/page.tsx` maps to `/dashboard`.
+  - API routes in `app/api/auth/route.ts` map to `/api/auth`.
+- **Nested layouts**:
+  - `app/layout.tsx` – Global wrapper with header and footer.
+  - `app/dashboard/layout.tsx` – Dashboard-specific wrapper with sidebar.
 
-**Navigation Structure**
-- **Header**: Present in global layout with the app logo and conditional Sign In/Sign Out links.
-- **Sidebar**: Included in `dashboard/layout.tsx` with links to dashboard sections (expandable in future).
+**Navigation**
+- Use Next.js’s `<Link>` component for client-side transitions without full page reloads.
+- Protect routes by checking `AuthContext` in `middleware.ts` or inside `layout.tsx`. If the user isn’t signed in, redirect to `/sign-in`.
 
 ---
 
 ## 7. Performance Optimization
 
-1. **Code Splitting**: Next.js automatically breaks code by route. Users only load JS needed for the current page.
-2. **Lazy Loading**: For large components (charts, maps), wrap with `next/dynamic` to load them only when needed.
-3. **Image Optimization**: Use Next.js `<Image>` component to serve responsive, compressed images.
-4. **Caching**:
-   - Static assets (CSS, fonts) use long cache headers.
-   - API responses can be cached or ISR (Incremental Static Regeneration) applied.
-5. **Minification & Compression**: Next.js production builds automatically minify JS and CSS, and enable Brotli/Gzip on the CDN.
+**Built-in Next.js features**
+- **SSR/SSG**: Pages are pre-rendered on the server or at build time for faster first paint.
+- **Automatic code splitting**: Only the JavaScript needed for the current page is loaded.
+- **Image optimization**: Use Next.js `<Image>` component to serve appropriately sized images.
 
-These steps ensure fast page loads and smooth interactions.
+**Additional Strategies**
+- **Dynamic imports** (`next/dynamic`) for heavy components or charts in the dashboard.
+- **Lazy-load non-critical assets** (e.g., third-party widgets) with `React.lazy` and `Suspense`.
+- **Minify and compress** CSS/JS during the build (handled automatically by Next.js).
 
 ---
 
 ## 8. Testing and Quality Assurance
 
+**Linting & Formatting**
+- **ESLint** with `eslint-config-next` to enforce best practices.
+- **Prettier** for consistent code formatting on save or pre-commit.
+
 **Unit Tests**
-- **Jest** + **React Testing Library** for components and utility functions.
-- Example: test that the Sign In form shows an error message when fields are empty.
+- **Jest** + **React Testing Library** for component logic and rendering tests.
+- Aim for testing:
+  - Form components (validation, error messages).
+  - Button clicks and UI state changes.
 
 **Integration Tests**
-- Combine multiple components and hooks; test API calls with **msw** (Mock Service Worker).
+- Mock API routes using **MSW** (Mock Service Worker) to simulate `/api/auth` responses.
+- Verify that pages fetch data correctly and render loading/error states.
 
-**End-to-End (E2E) Tests**
-- **Cypress** or **Playwright** to simulate real user flows: signing up, logging in, and viewing the dashboard.
+**End-to-End Tests**
+- **Cypress** or **Playwright** for full user flows:
+  - Sign-up ➔ Sign-in ➔ Dashboard access ➔ Sign-out.
+  - Redirects when not authenticated.
 
-**Linting & Formatting**
-- **ESLint** enforces code style and catches common bugs.
-- **Prettier** applies consistent formatting.
-- **Git Hooks** (via Husky) run linting/tests before each commit.
-
-**Continuous Integration (CI)**
-- **GitHub Actions** runs tests and lint on each pull request, preventing regressions.
+**Continuous Integration**
+- Run lint, unit, and integration tests on every pull request using **GitHub Actions**.
+- Block merges until all checks pass.
 
 ---
 
 ## 9. Conclusion and Overall Frontend Summary
 
-The `codeguide-starter` frontend is built on modern, well-established tools—Next.js, React, and TypeScript—and follows clear principles around usability, accessibility, and maintainability. Its file-based structure, component-driven approach, and CSS-variable theming keep things organized and consistent.
-
-Key takeaways:
-- **Scalable Structure**: Add new features by creating new folders under `app/` without touching a central router.
-- **Component Reuse**: Shared UI pieces live in one place, making updates quick and error-free.
-- **Simple Styling**: Global and section-specific CSS, underpinned by CSS variables, ensures a unified look.
-- **Smooth Performance**: Next.js automatic optimizations plus best practices like lazy loading and caching.
-- **Quality Assurance**: A testing plan that covers unit, integration, and E2E scenarios, enforced by CI.
-
-With these guidelines, any developer coming into the project can understand how the pieces fit together, how to follow existing patterns, and how to keep the app fast, reliable, and easy to grow.
\ No newline at end of file
+This guideline lays out a clear path for building, styling, and maintaining the frontend of our starter kit. By leveraging Next.js, React, and TypeScript, we ensure a scalable, high-performance foundation. Our design principles (usability, accessibility, responsiveness) keep the user experience front and center. A flat, modern visual style with a defined color palette and Inter font gives the app a clean look. Component-based structure and Context API state handling make the code easy to extend. File-based routing and nested layouts simplify navigation and consistency. Performance is optimized through SSR/SSG, code splitting, and image handling. Finally, a robust testing strategy—unit, integration, and end-to-end—backs up code quality. Together, these guidelines align with our goal: a reliable, developer-friendly starter that anyone can pick up and confidently build upon.
\ No newline at end of file
diff --git a/documentation/project_requirements_document.md b/documentation/project_requirements_document.md
index 526d663..49bffc9 100644
--- a/documentation/project_requirements_document.md
+++ b/documentation/project_requirements_document.md
@@ -1,117 +1,87 @@
-# Project Requirements Document: codeguide-starter
-
----
+# Project Requirements Document (PRD)
 
 ## 1. Project Overview
 
-The **codeguide-starter** project is a boilerplate web application that provides a ready-made foundation for any web project requiring secure user authentication and a post-login dashboard. It sets up the common building blocks—sign-up and sign-in pages, API routes to handle registration and login, and a simple dashboard interface driven by static data. By delivering this skeleton, it accelerates development time and ensures best practices are in place from day one.
+**Paragraph 1:**
+The `codeguide-starter-fullstack` is a ready-to-use starter kit for modern full-stack web applications. It lays out a solid project structure using a React-based framework (Next.js or Remix) with file-based routing, serverless API routes, and TypeScript. Out of the box, it includes user authentication (sign-up and sign-in), a protected user dashboard area, nested layouts for consistent UI, global styling, and a mock data source to populate components during development.
 
-This starter kit is being built to solve the friction developers face when setting up repeated common tasks: credential handling, session management, page routing, and theming. Key objectives include: 1) delivering a fully working authentication flow (registration & login), 2) providing a gated dashboard area upon successful login, 3) establishing a clear, maintainable project structure using Next.js and TypeScript, and 4) demonstrating a clean theming approach with global and section-specific CSS. Success is measured by having an end-to-end login journey in under 200 lines of code and zero runtime type errors.
-
----
+**Paragraph 2:**
+This starter aims to help developers save setup time and avoid repetitive boilerplate. By providing pre-configured authentication endpoints, layout components, and styling conventions, teams can focus on business logic and features instead of project scaffolding. Success is measured by how quickly a developer can clone the repo, run `npm install && npm run dev`, and see a functional sign-up/sign-in flow plus dashboard UI in under five minutes.
 
 ## 2. In-Scope vs. Out-of-Scope
 
-### In-Scope (Version 1)
-- User registration (sign-up) form with validation
-- User login (sign-in) form with validation
-- Next.js API routes under `/api/auth/route.ts` handling:
-  - Credential validation
-  - Password hashing (e.g., bcrypt)
-  - Session creation or JWT issuance
-- Protected dashboard pages under `/dashboard`:
-  - `layout.tsx` wrapping dashboard content
-  - `page.tsx` rendering static data from `data.json`
-- Global application layout in `/app/layout.tsx`
-- Basic styling via `globals.css` and `dashboard/theme.css`
-- TypeScript strict mode enabled
-
-### Out-of-Scope (Later Phases)
-- Integration with a real database (PostgreSQL, MongoDB, etc.)
-- Advanced authentication flows (password reset, email verification, MFA)
-- Role-based access control (RBAC)
-- Multi-tenant or white-label theming
-- Unit, integration, or end-to-end testing suites
-- CI/CD pipeline and production deployment scripts
-
----
+**In-Scope (Version 1):**
+- File-based routing under `app/` directory for pages and API routes.
+- Authentication endpoints in `app/api/auth/route.ts` supporting user sign-up and sign-in flows.
+- Sign-in page (`app/sign-in/page.tsx`) and sign-up page (`app/sign-up/page.tsx`) UIs.
+- Global layout (`app/layout.tsx`) and nested dashboard layout (`app/dashboard/layout.tsx`).
+- Dashboard page (`app/dashboard/page.tsx`) displaying mock data from `data.json`.
+- Global styles (`globals.css`) and theme overrides (`theme.css`).
+- Use of TypeScript (`.tsx` and `.ts` files) and React components.
+- Local mock data source for development, no external database required.
+
+**Out-of-Scope (Phase 2+):**
+- Integration with a real database (SQL, NoSQL) or ORM.
+- Third-party authentication providers (Google, GitHub, etc.).
+- Production-grade session management (JWT refresh tokens, secure cookies).
+- Advanced state management libraries (Redux, Zustand) beyond React Context.
+- Internationalization (i18n) and multi-locale support.
+- Comprehensive automated testing (unit, integration, end-to-end).
+- Deployment scripts or CI/CD pipelines.
 
 ## 3. User Flow
 
-A new visitor lands on the root URL and sees a welcome page with options to **Sign Up** or **Sign In**. If they choose Sign Up, they fill in their email, password, and hit “Create Account.” The form submits to `/api/auth/route.ts`, which hashes the password, creates a new user session or token, and redirects them to the dashboard. If any input is invalid, an inline error message explains the issue (e.g., “Password too short”).
-
-Once authenticated, the user is taken to the `/dashboard` route. Here they see a sidebar or header defined by `dashboard/layout.tsx`, and the main panel pulls in static data from `data.json`. They can log out (if that control is present), but otherwise their entire session is managed by server-side cookies or tokens. Returning users go directly to Sign In, submit credentials, and upon success they land back on `/dashboard`. Any unauthorized access to `/dashboard` redirects back to Sign In.
+**Paragraph 1:**
+A new visitor lands on the homepage and sees options to "Sign Up" or "Sign In" in the navigation bar (rendered by `app/layout.tsx`). If they choose "Sign Up," they are taken to `/sign-up`, where `app/sign-up/page.tsx` shows a form asking for email and password. On submission, the form calls the API endpoint at `/api/auth/route.ts`. If registration succeeds, the user is automatically redirected to the dashboard; if it fails, an inline error message appears.
 
----
+**Paragraph 2:**
+Returning users click "Sign In" and arrive at `/sign-in`. After entering credentials, the form POSTs to `/api/auth/route.ts`. On successful authentication, the user session is stored (in memory or via cookie), and the user is redirected to `/dashboard`. The dashboard page (`app/dashboard/page.tsx`) loads mock data from `data.json`, and its layout (`app/dashboard/layout.tsx`) adds a sidebar or header specific to dashboard pages. Users can navigate back to other pages or log out, which clears the session and returns them to the sign-in page.
 
 ## 4. Core Features
 
-- **Sign-Up Page (`/app/sign-up/page.tsx`)**: Form fields for email & password, client-side validation, POST to `/api/auth`.
-- **Sign-In Page (`/app/sign-in/page.tsx`)**: Form fields for email & password, client-side validation, POST to `/api/auth`.
-- **Authentication API (`/app/api/auth/route.ts`)**: Handles both registration and login based on HTTP method, integrates password hashing (bcrypt) and session or JWT logic.
-- **Global Layout (`/app/layout.tsx` + `globals.css`)**: Shared header, footer, and CSS resets across all pages.
-- **Dashboard Layout (`/app/dashboard/layout.tsx` + `dashboard/theme.css`)**: Sidebar or top nav for authenticated flows, section-specific styling.
-- **Dashboard Page (`/app/dashboard/page.tsx`)**: Reads `data.json`, renders it as cards or tables.
-- **Static Data Source (`/app/dashboard/data.json`)**: Example dataset to demo dynamic rendering.
-- **TypeScript Configuration**: `tsconfig.json` with strict mode and path aliases (if any).
-
----
+- **Authentication Module**: Sign-up and sign-in endpoints in `app/api/auth/route.ts`. Handles POST requests for new users and login, performs basic validation.
+- **Protected Dashboard**: A `/dashboard` route that checks authentication; unauthenticated requests redirect to `/sign-in`.
+- **Nested Layouts**: `app/layout.tsx` for global elements (header, footer), `app/dashboard/layout.tsx` for dashboard-specific navigation.
+- **File-Based Routing**: URL paths map to folders and files under `app/` (e.g., `app/sign-up/page.tsx` → `/sign-up`).
+- **Mock Data Source**: `data.json` provides sample data for the dashboard to render charts or lists without a real backend.
+- **Styling**: `globals.css` for site-wide styles, `theme.css` for color palettes and overrides. Supports future integration with CSS modules or Tailwind.
+- **TypeScript & React**: All components and routes use `.tsx` and `.ts` for type safety and clarity.
 
 ## 5. Tech Stack & Tools
 
-- **Framework**: Next.js (App Router) for file-based routing, SSR/SSG, and API routes.
-- **Language**: TypeScript for type safety.
-- **UI Library**: React 18 for component-based UI.
-- **Styling**: Plain CSS via `globals.css` (global reset) and `theme.css` (sectional styling). Can easily migrate to CSS Modules or Tailwind in the future.
-- **Backend**: Node.js runtime provided by Next.js API routes.
-- **Password Hashing**: bcrypt (npm package).
-- **Session/JWT**: NextAuth.js or custom JWT logic (to be decided in implementation).
-- **IDE & Dev Tools**: VS Code with ESLint, Prettier extensions. Optionally, Cursor.ai for AI-assisted coding.
-
----
+**Frontend**: Next.js 13 (or Remix), React 18, TypeScript 4.x.  
+**Backend/API**: Node.js 16+, built-in API routes of Next.js/Remix.  
+**Styling**: Plain CSS (`globals.css`, `theme.css`), ready for Tailwind or CSS modules.  
+**Linting & Formatting**: ESLint with `eslint-config-next` (or equivalent), Prettier.  
+**Mock Data**: Static JSON file (`data.json`) within repo.  
+**IDE Plugins**: Optional ESLint and Prettier integrations.  
+**Version Control**: Git, with a standard `.gitignore` for Node and VSCode.
 
 ## 6. Non-Functional Requirements
 
-- **Performance**: Initial page load under 200 ms on a standard broadband connection. API responses under 300 ms.
-- **Security**:
-  - HTTPS only in production.
-  - Proper CORS, CSRF protection for API routes.
-  - Secure password storage (bcrypt with salt).
-  - No credentials or secrets checked into version control.
-- **Scalability**: Structure must support adding database integration, caching layers, and advanced auth flows without rewiring core app.
-- **Usability**: Forms should give real-time feedback on invalid input. Layout must be responsive (mobile > 320 px).
-- **Maintainability**: Code must adhere to TypeScript strict mode. Linting & formatting enforced by ESLint/Prettier.
-
----
+- **Performance**: First meaningful paint under 2 seconds on a 3G network. API calls should return within 200ms in development mode.
+- **Security**: Sanitize user inputs. Hash passwords before storage (even in mock). Set HTTP-only and Secure flags if cookies are used.
+- **Scalability**: Clear separation of UI, API, and data layers to allow future growth.
+- **Usability**: Responsive design, semantic HTML, basic ARIA roles for forms and navigation. Works on desktop and mobile screens.
+- **Maintainability**: Strict TS config (`noImplicitAny`, `strictNullChecks`), consistent code style enforced by ESLint/Prettier.
+- **Compliance**: Code organized to allow easy GDPR opt-in/out for user data.
 
 ## 7. Constraints & Assumptions
 
-- **No Database**: Dashboard uses only `data.json`; real database integration is deferred.
-- **Node Version**: Requires Node.js >= 14.
-- **Next.js Version**: Built on Next.js 13+ App Router.
-- **Authentication**: Assumes availability of bcrypt or NextAuth.js at implementation time.
-- **Hosting**: Targets serverless or Node.js-capable hosting (e.g., Vercel, Netlify).
-- **Browser Support**: Modern evergreen browsers; no IE11 support required.
-
----
+- **Framework Choice**: Assumes Next.js 13 conventions—React Server Components, file-based routing. If Remix is chosen, adapt folder names to `routes/` instead of `app/`.
+- **Mock Data Only**: No real database connection; data lives in `data.json`. Future phases must swap this out with real DB logic.
+- **Node Environment**: Requires Node.js version 16 or higher.
+- **Session Storage**: Assumes in-memory or cookie session for development. Production session store (Redis, etc.) is not included.
+- **Single Language**: English UI only.
 
 ## 8. Known Issues & Potential Pitfalls
 
-- **Static Data Limitation**: `data.json` is only for demo. A real API or database will be needed to avoid stale data.
-  *Mitigation*: Define a clear interface for data fetching so swapping to a live endpoint is trivial.
-
-- **Global CSS Conflicts**: Using global styles can lead to unintended overrides.
-  *Mitigation*: Plan to migrate to CSS Modules or utility-first CSS in Phase 2.
-
-- **API Route Ambiguity**: Single `/api/auth/route.ts` handling both sign-up and sign-in could get complex.
-  *Mitigation*: Clearly branch on HTTP method (`POST /register` vs. `POST /login`) or split into separate files.
-
-- **Lack of Testing**: No test suite means regressions can slip in.
-  *Mitigation*: Build a minimal Jest + React Testing Library setup in an early iteration.
-
-- **Error Handling Gaps**: Client and server must handle edge cases (network failures, malformed input).
-  *Mitigation*: Define a standard error response schema and show user-friendly messages.
+- **Ambiguous Framework**: The code structure could fit Next.js or Remix. Pick one and align config (e.g., `next.config.js` vs `remix.config.js`).  
+- **Authentication Security**: Current route handler may lack robust hashing, salting, and CSRF protection. Plan to integrate `bcrypt` and CSRF tokens in Phase 2.  
+- **Hydration Mismatch**: Using React Server Components and client components improperly can cause hydration errors. Clearly mark client functions with `'use client'`.  
+- **Mock Data Limitations**: Relying on a static JSON file means no real state updates. For CRUD patterns, swap in a fake REST server (json-server) or stubbed GraphQL mock.  
+- **Global CSS Collisions**: Without CSS modules or namespacing, global styles can clash. Recommend migrating to CSS modules or utility classes for larger apps.
 
 ---
 
-This PRD should serve as the single source of truth for the AI model or any developer generating the next set of technical documents: Tech Stack Doc, Frontend Guidelines, Backend Structure, App Flow, File Structure, and IDE Rules. It contains all functional and non-functional requirements with no ambiguity, enabling seamless downstream development.
+This PRD should serve as the single source of truth for all subsequent technical docs—tech stack details, frontend and backend guidelines, file structures, and app flow definitions. Every requirement here is precise to avoid any guesswork during implementation.
\ No newline at end of file
diff --git a/documentation/security_guideline_document.md b/documentation/security_guideline_document.md
index 683c23f..d4bfde5 100644
--- a/documentation/security_guideline_document.md
+++ b/documentation/security_guideline_document.md
@@ -1,116 +1,195 @@
-# Security Guidelines for codeguide-starter
+# Security Guidelines for `codeguide-starter-fullstack`
 
-This document defines mandatory security principles and implementation best practices tailored to the **codeguide-starter** repository. It aligns with Security-by-Design, Least Privilege, Defense-in-Depth, and other core security tenets. All sections reference specific areas of the codebase (e.g., `/app/api/auth/route.ts`, CSS files, environment configuration) to ensure practical guidance.
+This document provides actionable security best practices for the `codeguide-starter-fullstack` starter kit. By following these guidelines, developers will embed security by design, ensure robust defenses, and maintain a secure default posture throughout development and deployment.
 
 ---
 
-## 1. Security by Design
+## 1. Security Principles  
+Embed these principles at every stage of development:
 
-• Embed security from day one: review threat models whenever adding new features (e.g., new API routes, data fetching).
-• Apply “secure defaults” in Next.js configuration (`next.config.js`), enabling strict mode and disabling debug flags in production builds.
-• Maintain a security checklist in your PR template to confirm that each change has been reviewed against this guideline.
+- **Security by Design:** Integrate security from the first line of code.  
+- **Least Privilege:** Grant the minimum access needed (file system, environment, database).  
+- **Defense in Depth:** Layer controls (validation, authentication, headers).  
+- **Fail Securely:** On error, do not leak data or leave an operation half-completed.  
+- **Keep Security Simple:** Use well-maintained libraries and patterns.  
+- **Secure Defaults:** Ensure all new features are locked down until explicitly opened.
 
 ---
 
 ## 2. Authentication & Access Control
 
-### 2.1 Password Storage
-- Use **bcrypt** (or Argon2) with a per-user salt to hash passwords in `/app/api/auth/route.ts`.
-- Enforce a strong password policy on both client and server: minimum 12 characters, mixed case, numbers, and symbols.
+- **Strong Password Policies:**  
+  • Enforce minimum length (≥ 8 characters), complexity rules, and blacklists.  
+  • Use `bcrypt` or `Argon2` with unique salts for hashing.  
 
-### 2.2 Session Management
-- Issue sessions via Secure, HttpOnly, SameSite=strict cookies. Do **not** expose tokens to JavaScript.
-- Implement absolute and idle timeouts. For example, invalidate sessions after 30 minutes of inactivity.
-- Protect against session fixation by regenerating session IDs after authentication.
+- **Secure Session Management:**  
+  • Store session tokens in HTTP-only, Secure, `SameSite=Strict` cookies.  
+  • Implement idle and absolute timeouts (e.g., 15 min idle, 24 h absolute).  
+  • Regenerate session ID on login to prevent fixation.  
 
-### 2.3 Brute-Force & Rate Limiting
-- Apply rate limiting at the API layer (e.g., using `express-rate-limit` or Next.js middleware) on `/api/auth` to throttle repeated login attempts.
-- Introduce exponential backoff or temporary lockout after N failed attempts.
+- **JWT Handling (if adopted):**  
+  • Use strong signing algorithms (e.g., HS256 or RS256).  
+  • Validate `alg`, `iss`, `aud`, and enforce short expirations (`exp`).  
+  • Do not store sensitive user data in the token payload.  
 
-### 2.4 Role-Based Access Control (Future)
-- Define user roles in your database model (e.g., `role = 'user' | 'admin'`).
-- Enforce server-side authorization checks in every protected route (e.g., in `dashboard/layout.tsx` loader functions).
+- **Multi-Factor Authentication (MFA):**  
+  • Provide optional TOTP-based or SMS-based 2FA for sensitive flows.  
+
+- **Role-Based Access Control (RBAC):**  
+  • Define roles (e.g., `user`, `admin`) and enforce server-side checks in every API route and page.  
+  • Never rely on client-side flags for authorization.
 
 ---
 
 ## 3. Input Handling & Processing
 
-### 3.1 Validate & Sanitize All Inputs
-- On **client** (`sign-up/page.tsx`, `sign-in/page.tsx`): perform basic format checks (email regex, password length).
-- On **server** (`/app/api/auth/route.ts`): re-validate inputs with a schema validator (e.g., `zod`, `Joi`).
-- Reject or sanitize any unexpected fields to prevent injection attacks.
+- **Server-Side Validation:**  
+  • Validate every request body, query, and parameter using schemas (e.g., Zod or Joi).  
+  • Mirror client-side validation with stricter server rules.
+
+- **Prevent Injection:**  
+  • Use parameterized queries or an ORM for any DB access.  
+  • Never interpolate user input into command lines or file paths.
+
+- **Cross-Site Scripting (XSS) Mitigation:**  
+  • Escape or sanitize all user-supplied content before rendering.  
+  • Avoid `dangerouslySetInnerHTML`; if needed, sanitize with a library (e.g., DOMPurify).
 
-### 3.2 Prevent Injection
-- If you introduce a database later, always use parameterized queries or an ORM (e.g., Prisma) rather than string concatenation.
-- Avoid dynamic `eval()` or template rendering with unsanitized user input.
+- **Redirect and URL Validation:**  
+  • Allow-list redirect targets.  
+  • Reject or default to a safe path for invalid `next` parameters.
 
-### 3.3 Safe Redirects
-- When redirecting after login or logout, validate the target against an allow-list to prevent open redirects.
+- **Secure File Uploads (Future Scope):**  
+  • Validate file size, type (by magic bytes), and reject disallowed extensions.  
+  • Store uploads outside the webroot or on a dedicated object store with least privilege.
 
 ---
 
 ## 4. Data Protection & Privacy
 
-### 4.1 Encryption & Secrets
-- Enforce HTTPS/TLS 1.2+ for all front-end ↔ back-end communications.
-- Never commit secrets—use environment variables and a secrets manager (e.g., AWS Secrets Manager, Vault).
+- **Encryption in Transit:**  
+  • Enforce TLS 1.2+ on all endpoints (e.g., via Vercel defaults or custom NGINX).  
+
+- **Encryption at Rest:**  
+  • For persistent storage (databases, object stores), enable encryption features.  
+
+- **Secrets Management:**  
+  • Store secrets (DB credentials, JWT keys) in environment variables or a vault (AWS Secrets Manager, HashiCorp Vault).  
+  • Avoid committing `.env` files to source control.
+
+- **Information Leakage:**  
+  • In production, disable detailed stack traces.  
+  • Return generic error messages (e.g., "An unexpected error occurred.").
 
-### 4.2 Sensitive Data Handling
-- Do ​not​ log raw passwords, tokens, or PII in server logs. Mask or redact any user identifiers.
-- If storing PII in `data.json` or a future database, classify it and apply data retention policies.
+- **Protect PII:**  
+  • Mask or truncate sensitive fields in logs (emails, user IDs).  
+  • Implement a data retention policy that aligns with GDPR/CCPA.
 
 ---
 
 ## 5. API & Service Security
 
-### 5.1 HTTPS Enforcement
-- In production, redirect all HTTP traffic to HTTPS (e.g., via Vercel’s redirect rules or custom middleware).
+- **HTTPS Enforcement:**  
+  • Redirect HTTP to HTTPS at the edge.  
 
-### 5.2 CORS
-- Configure `next.config.js` or API middleware to allow **only** your front-end origin (e.g., `https://your-domain.com`).
+- **Rate Limiting & Throttling:**  
+  • Apply per-IP or per-user rate limits on authentication and write endpoints.  
 
-### 5.3 API Versioning & Minimal Exposure
-- Version your API routes (e.g., `/api/v1/auth`) to handle future changes without breaking clients.
-- Return only necessary fields in JSON responses; avoid leaking internal server paths or stack traces.
+- **CORS Configuration:**  
+  • Restrict `Access-Control-Allow-Origin` to trusted domains.  
+  • Enable `Access-Control-Allow-Credentials` only when needed.
+
+- **Authentication & Authorization Checks:**  
+  • Protect every API route under `app/api/` with middleware that verifies the session or token.  
+
+- **Minimal Response Surface:**  
+  • Only return necessary fields in JSON replies.  
+  • Avoid verbosity that could leak internal implementation details.
+
+- **Proper HTTP Methods:**  
+  • GET for read, POST for create, PUT/PATCH for update, DELETE for removal.  
+
+- **API Versioning:**  
+  • Use route prefixes like `/api/v1/auth` to allow safe iteration.
 
 ---
 
 ## 6. Web Application Security Hygiene
 
-### 6.1 CSRF Protection
-- Use anti-CSRF tokens for any state-changing API calls. Integrate Next.js CSRF middleware or implement synchronizer tokens stored in cookies.
+- **Cross-Site Request Forgery (CSRF):**  
+  • Implement CSRF tokens on state-changing requests (e.g., using `next-csrf` or `csurf`).
+
+- **Security Headers:**  
+  • Content-Security-Policy: limit sources of scripts, styles, images.  
+  • Strict-Transport-Security: `max-age=63072000; includeSubDomains; preload`.  
+  • X-Content-Type-Options: `nosniff`.  
+  • X-Frame-Options: `DENY`.  
+  • Referrer-Policy: `no-referrer-when-downgrade` or stricter.
+
+- **Secure Cookies:**  
+  • Set `HttpOnly`, `Secure`, `SameSite=Strict` on all session cookies.
 
-### 6.2 Security Headers
-- In `next.config.js` (or a custom server), add these headers:
-  - `Strict-Transport-Security: max-age=63072000; includeSubDomains; preload`
-  - `X-Content-Type-Options: nosniff`
-  - `X-Frame-Options: DENY`
-  - `Referrer-Policy: no-referrer-when-downgrade`
-  - `Content-Security-Policy`: restrict script/style/src to self and trusted CDNs.
+- **Clickjacking Protection:**  
+  • Enforce `X-Frame-Options: DENY` or CSP `frame-ancestors 'none'`.
 
-### 6.3 Secure Cookies
-- Set `Secure`, `HttpOnly`, `SameSite=Strict` on all cookies. Avoid storing sensitive data in `localStorage`.
+- **Avoid Client-Side Storage of Secrets:**  
+  • Never store tokens or passwords in `localStorage` or `sessionStorage`.
 
-### 6.4 Prevent XSS
-- Escape or encode all user-supplied data in React templates. Avoid `dangerouslySetInnerHTML` unless content is sanitized.
+- **Subresource Integrity (SRI):**  
+  • When including third-party scripts/styles, add integrity hashes.
 
 ---
 
 ## 7. Infrastructure & Configuration Management
 
-- Harden your hosting environment (e.g., Vercel/Netlify) by disabling unnecessary endpoints (GraphQL/GraphiQL playgrounds in production).
-- Rotate secrets and API keys regularly via your secrets manager.
-- Maintain minimal privileges: e.g., database accounts should only have read/write on required tables.
-- Keep Node.js, Next.js, and all system packages up to date.
+- **Server Hardening:**  
+  • Disable unused services and ports.  
+  • Regularly apply OS and package updates.
 
+- **Environment Segmentation:**  
+  • Separate development, staging, and production configurations.  
+  • Use distinct credentials and secrets per environment.
+
+- **TLS Configuration:**  
+  • Disable weak ciphers and protocols (SSLv3, TLS 1.0/1.1).  
+  • Test with tools like SSL Labs for compliance.
+
+- **File Permissions:**  
+  • Restrict filesystem access—only necessary users should read/write code and logs.
+
+- **Disable Debug in Production:**  
+  • Ensure `next.config.js` sets `reactStrictMode=false` only in development.
+  
 ---
 
 ## 8. Dependency Management
 
-- Commit and maintain `package-lock.json` to guarantee reproducible builds.
-- Integrate a vulnerability scanner (e.g., GitHub Dependabot, Snyk) to monitor and alert on CVEs in dependencies.
-- Trim unused packages; each added library increases the attack surface.
+- **Lockfiles:**  
+  • Commit `package-lock.json` or `yarn.lock` for reproducible builds.
+
+- **Vulnerability Scanning:**  
+  • Integrate SCA tools (e.g., GitHub Dependabot, Snyk) into CI.  
+
+- **Update Regularly:**  
+  • Schedule periodic dependency reviews and upgrades.  
+
+- **Limit Footprint:**  
+  • Only install essential packages to reduce the attack surface.
+
+---
+
+## 9. Continuous Security Practices
+
+- **Automated CI/CD Checks:**  
+  • Linting, type-checking, and vulnerability scanning on every pull request.  
+
+- **Penetration Testing & Audits:**  
+  • Conduct periodic security reviews or engage third-party auditors.  
+
+- **Incident Response Plan:**  
+  • Define steps for breach detection, containment, and notification.
 
 ---
 
-Adherence to these guidelines will ensure that **codeguide-starter** remains secure, maintainable, and resilient as it evolves. Regularly review and update this document to reflect new threats and best practices.
\ No newline at end of file
+## Conclusion
+By adopting these guidelines, the `codeguide-starter-fullstack` repository will maintain strong security hygiene, protect user data, and ensure a resilient foundation for future features. Always treat security as a continuous process and evolve controls as the application grows.
diff --git a/documentation/tech_stack_document.md b/documentation/tech_stack_document.md
index 6db3f9b..8d0fcdb 100644
--- a/documentation/tech_stack_document.md
+++ b/documentation/tech_stack_document.md
@@ -1,90 +1,120 @@
 # Tech Stack Document
 
-This document explains the key technologies chosen for the **codeguide-starter** project. It’s written in everyday language so anyone—technical or not—can understand why each tool was picked and how it supports the application.
+This document explains the technology choices for the `codeguide-starter-fullstack` project in everyday language. Each section describes why we picked certain tools and how they work together to build a solid foundation for your web application.
 
 ## 1. Frontend Technologies
-The frontend is everything the user sees and interacts with. For this project, we’ve used:
 
-- **Next.js (App Router)**
-  - A React framework that makes page routing, server-side rendering, and API routes very simple.
-  - Enhances user experience by pre-rendering pages on the server or at build time, leading to faster initial load.
+We use modern tools to build a fast, interactive user interface that’s easy to maintain:
+
+- **Next.js (React Framework)**
+  - Provides file-based routing: your folders and files under `app/` automatically become pages and API endpoints.
+  - Supports server-side rendering (SSR) and static site generation (SSG) out of the box, improving load times and SEO.
 - **React 18**
-  - The underlying library for building user interfaces with reusable components.
-  - Provides a smooth, interactive experience thanks to its virtual DOM and modern hooks.
+  - Lets us build UI as reusable components that update smoothly when data changes.
 - **TypeScript**
-  - A superset of JavaScript that adds types (labels for data).
-  - Helps catch errors early during development and makes the code easier to maintain.
+  - Adds type safety (checks for mistakes before you even run the code), making the codebase more reliable and easier to understand.
 - **CSS (globals.css & theme.css)**
-  - **globals.css** applies base styles (fonts, colors, resets) across the entire app.
-  - **dashboard/theme.css** defines the look and feel specific to the dashboard area.
-  - This separation keeps styles organized and avoids accidental style conflicts.
+  - `globals.css` sets site-wide styles (colors, fonts, spacing).
+  - `theme.css` defines color palettes and design tokens so you can change the look in one place.
+- **ESLint & Prettier**
+  - Enforce consistent code style and catch potential errors early in development.
+
+How these choices enhance the user experience:
 
-By combining these tools, we have a clear structure (Next.js folders for pages and layouts), safer code (TypeScript), and flexible styling with vanilla CSS.
+- Fast initial load through SSR/SSG in Next.js.
+- Component-based React keeps UI consistent and makes changes predictable.
+- TypeScript helps avoid common mistakes, so features work as expected.
+- Centralized styling files ensure a uniform look and make theme updates simple.
 
 ## 2. Backend Technologies
-The backend handles data, user accounts, and the logic behind the scenes. Our choices here are:
 
-- **Next.js API Routes**
-  - Allows us to write server-side code (`route.ts` files) alongside our frontend in the same project.
-  - Runs on Node.js, so we can handle requests like sign-up, sign-in, and data fetching in one place.
-- **Node.js Runtime**
-  - The JavaScript environment on the server that executes our API routes.
-- **bcrypt** (npm package)
-  - A library for hashing passwords securely before storing them.
-  - Ensures that even if someone got access to our data, raw passwords aren’t visible.
-- **(Optional) NextAuth.js or JWT**
-  - While this starter kit shows a custom authentication flow, it can easily integrate services like NextAuth.js for email-based login or JWT (JSON Web Tokens) for stateless sessions.
+Our backend is lightweight and lives in the same project, handling data and authentication:
+
+- **Next.js API Routes (`app/api/auth/route.ts`)**
+  - Let you create server-side endpoints (sign-up, sign-in) without a separate server.
+  - Keep frontend and backend logic together for faster iteration.
+- **Node.js (v16+)**
+  - Runs JavaScript on the server side. It’s fast, widely supported, and works seamlessly with Next.js.
+- **Local JSON Data (`data.json`)**
+  - Acts as a mock database during development.
+  - Lets you prototype UI and data views quickly without setting up a real database.
 
-These components work together to receive user credentials, verify or store them securely, manage sessions or tokens, and deliver protected data back to the frontend.
+How these pieces work together:
+
+1. A user submits credentials on the sign-in/sign-up page.  
+2. The form sends a request to an API route in the same codebase.  
+3. The API route processes the data (e.g., validate email, hash password).  
+4. On success, the route responds, and Next.js redirects the user to the dashboard.  
+5. The dashboard page reads from `data.json` to display sample content.
 
 ## 3. Infrastructure and Deployment
-Infrastructure covers where and how we host the app, as well as how changes get delivered:
 
-- **Git & GitHub**
-  - Version control system (Git) and remote hosting (GitHub) keep track of all code changes and allow team collaboration.
-- **Vercel (or Netlify)**
-  - A popular hosting service optimized for Next.js, with one-click deployments and global content delivery.
-  - Automatically rebuilds and deploys the site whenever code is pushed to the main branch.
-- **GitHub Actions (CI/CD)**
-  - Automates tasks like linting (ESLint), formatting (Prettier), and running any tests you add.
-  - Ensures that only clean, tested code goes live.
+To keep deployments simple, reliable, and scalable, we recommend:
+
+- **Version Control: Git & GitHub**
+  - Store and track all code changes in Git.
+  - Collaborate easily through pull requests on GitHub.
+- **Hosting Platform: Vercel**
+  - First-class support for Next.js applications.
+  - Automatic deployments when you push to the main branch.
+  - Free SSL certificates and global CDN for fast page loads.
+- **CI/CD Pipeline: GitHub Actions**
+  - Automatically run linting and tests on every pull request.
+  - Deploy to Vercel (or another cloud) after checks pass.
+
+How these decisions help:
 
-Together, these tools provide a reliable, scalable setup where every code change is tested and deployed quickly, with minimal manual work.
+- **Reliability:** Automated checks catch errors before they reach production.
+- **Scalability:** Vercel’s CDN scales your app globally without extra setup.
+- **Ease of Deployment:** Push to GitHub, and your app goes live—no manual steps needed.
 
 ## 4. Third-Party Integrations
-While this starter kit is minimal by design, it already includes or can easily add:
 
-- **bcrypt**
-  - For secure password hashing (included as an npm dependency).
-- **NextAuth.js** (optional)
-  - A full-featured authentication library supporting email/password, OAuth, and more.
-- **Sentry or LogRocket** (optional)
-  - For real-time error tracking and performance monitoring in production.
+In this starter kit, we keep integrations minimal to stay focused on core features:
 
-These integrations help extend the app’s capabilities without building every feature from scratch.
+- **None by default**
+  - No external APIs or services are tied in at this stage.
+
+Future integrations might include:
+
+- **Authentication Providers** (Google, GitHub)  
+  - Let users sign in with existing accounts.
+- **Analytics Tools** (Google Analytics, Plausible)  
+  - Track user behavior and measure performance.
+- **Payment Processors** (Stripe)  
+  - Handle subscriptions or one-time payments.
+
+Adding these later is straightforward once the foundation is in place.
 
 ## 5. Security and Performance Considerations
-We’ve baked in several measures to keep users safe and the app running smoothly:
 
-Security:
-- Passwords are never stored in plain text—bcrypt hashes them with a random salt.
-- API routes can implement CSRF protection and input validation to block malicious requests.
-- Session tokens or cookies are marked secure and HttpOnly to prevent theft via JavaScript.
+We’ve built in basic safeguards and performance steps to keep users safe and happy:
 
-Performance:
-- Server-side rendering (SSR) and static site generation (SSG) in Next.js deliver pages faster.
-- Code splitting and lazy-loaded components ensure users only download what they need.
-- Global CSS and theme files are small and cached by the browser for quick repeat visits.
+- **Security Measures:**
+  - **Password Handling:** Hash passwords (e.g., via `bcrypt`) before storing them (even in a mock scenario).
+  - **Secure Cookies:** Store sessions in HTTP-only cookies to prevent JavaScript access.
+  - **Input Validation:** Check user input on both client and server to avoid bad data.
+  - **Redirect Protection:** Unauthenticated users get sent back to the sign-in page if they try to access `/dashboard`.
+- **Performance Optimizations:**
+  - **Server-Side Rendering:** Next.js pre-renders pages for faster first load.
+  - **Static Assets on CDN:** All CSS and images served from a content delivery network.
+  - **Code Splitting:** Only load the JavaScript needed for each page, keeping initial downloads small.
 
-These strategies work together to give users a fast, secure experience every time.
+These practices ensure a smooth, secure experience for end users.
 
 ## 6. Conclusion and Overall Tech Stack Summary
-In building **codeguide-starter**, we chose technologies that:
 
-- Align with modern web standards (Next.js, React, TypeScript).
-- Provide a clear, file-based project structure for rapid onboarding.
-- Offer built-in support for server-side rendering, API routes, and static assets.
-- Emphasize security through password hashing, session management, and safe defaults.
-- Enable easy scaling and future enhancements via modular code and optional integrations.
+To recap, here’s why each major technology was chosen and how it aligns with our goals:
+
+- **Next.js + React + TypeScript**: Fast, SEO-friendly pages with type safety and component reusability.
+- **API Routes & Node.js**: Simple, serverless backend logic lives in the same codebase for quick iteration.
+- **CSS Styling**: Clear separation of global styles and theme variables makes design changes easy.
+- **Git + GitHub + Vercel + GitHub Actions**: A streamlined workflow from code changes to production deployment.
+
+This combination delivers:
+
+- A **robust starter** that handles authentication, routing, and layouts right away.
+- A **friendly developer experience**: clone the repo, install dependencies, and see a working app in minutes.
+- A **scalable platform**: ready to add real databases, third-party services, and advanced features as your project grows.
 
-This stack strikes a balance between simplicity for newcomers and flexibility for experienced teams. It accelerates development of a secure authentication flow and a polished dashboard, while leaving room to plug in databases, test suites, and advanced features as the project grows.
\ No newline at end of file
+With this tech stack, teams can focus on building features instead of wrestling with configuration. You have everything you need to start a modern full-stack web application with confidence.
\ No newline at end of file
diff --git a/hooks/useKanbanState.ts b/hooks/useKanbanState.ts
new file mode 100644
index 0000000..3749c50
--- /dev/null
+++ b/hooks/useKanbanState.ts
@@ -0,0 +1,158 @@
+'use client'
+
+import { useState, useCallback } from 'react'
+import { KanbanBoard, KanbanTask, KanbanColumn } from '@/types/kanban'
+
+export function useKanbanState(initialBoard: KanbanBoard) {
+  const [board, setBoard] = useState<KanbanBoard>(initialBoard)
+
+  const updateTask = useCallback((taskId: string, updates: Partial<KanbanTask>) => {
+    setBoard(prevBoard => ({
+      ...prevBoard,
+      columns: prevBoard.columns.map(column => ({
+        ...column,
+        tasks: column.tasks.map(task => 
+          task.id === taskId ? { ...task, ...updates } : task
+        )
+      })),
+      updatedAt: new Date().toISOString()
+    }))
+  }, [])
+
+  const addTask = useCallback((columnId: string, newTask: Partial<KanbanTask>) => {
+    setBoard(prevBoard => ({
+      ...prevBoard,
+      columns: prevBoard.columns.map(column => {
+        if (column.id === columnId) {
+          const task: KanbanTask = {
+            id: `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            title: '',
+            description: '',
+            priority: 'medium',
+            status: column.status,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            ...newTask
+          } as KanbanTask
+
+          return {
+            ...column,
+            tasks: [...column.tasks, task]
+          }
+        }
+        return column
+      }),
+      updatedAt: new Date().toISOString()
+    }))
+  }, [])
+
+  const deleteTask = useCallback((taskId: string) => {
+    setBoard(prevBoard => ({
+      ...prevBoard,
+      columns: prevBoard.columns.map(column => ({
+        ...column,
+        tasks: column.tasks.filter(task => task.id !== taskId)
+      })),
+      updatedAt: new Date().toISOString()
+    }))
+  }, [])
+
+  const moveTask = useCallback((taskId: string, targetColumnId: string, newStatus: 'todo' | 'in-progress' | 'done') => {
+    setBoard(prevBoard => {
+      // Find the task to move
+      let taskToMove: KanbanTask | null = null
+      const sourceColumns = prevBoard.columns.map(column => {
+        const taskIndex = column.tasks.findIndex(task => task.id === taskId)
+        if (taskIndex >= 0) {
+          taskToMove = column.tasks[taskIndex]
+          return {
+            ...column,
+            tasks: column.tasks.filter(task => task.id !== taskId)
+          }
+        }
+        return column
+      })
+
+      if (!taskToMove) {
+        return prevBoard
+      }
+
+      // Update the task status and add to target column
+      const updatedTask: KanbanTask = {
+        ...taskToMove,
+        status: newStatus,
+        updatedAt: new Date().toISOString()
+      }
+
+      const updatedColumns = sourceColumns.map(column => {
+        if (column.id === targetColumnId) {
+          return {
+            ...column,
+            tasks: [...column.tasks, updatedTask]
+          }
+        }
+        return column
+      })
+
+      return {
+        ...prevBoard,
+        columns: updatedColumns,
+        updatedAt: new Date().toISOString()
+      }
+    })
+  }, [])
+
+  const saveTaskChanges = useCallback((task: Partial<KanbanTask>, targetColumnId?: string) => {
+    if (!task.id) {
+      // This is a new task, find the appropriate column to add it to
+      let columnId = targetColumnId
+      if (!columnId) {
+        const targetColumn = board.columns.find(col => 
+          task.status ? col.status === task.status : col.status === 'todo'
+        )
+        columnId = targetColumn?.id
+      }
+      
+      if (columnId) {
+        addTask(columnId, task)
+      }
+    } else {
+      // This is an existing task, update it
+      updateTask(task.id, task)
+    }
+  }, [board.columns, addTask, updateTask])
+
+  // Helper function to get task by ID
+  const getTask = useCallback((taskId: string): KanbanTask | null => {
+    for (const column of board.columns) {
+      const task = column.tasks.find(t => t.id === taskId)
+      if (task) return task
+    }
+    return null
+  }, [board.columns])
+
+  // Helper function to get column by task ID
+  const getColumnByTaskId = useCallback((taskId: string): KanbanColumn | null => {
+    return board.columns.find(column => 
+      column.tasks.some(task => task.id === taskId)
+    ) || null
+  }, [board.columns])
+
+  // Helper function to get column by ID
+  const getColumn = useCallback((columnId: string): KanbanColumn | null => {
+    return board.columns.find(column => column.id === columnId) || null
+  }, [board.columns])
+
+  return {
+    board,
+    setBoard,
+    updateTask,
+    addTask,
+    deleteTask,
+    moveTask,
+    saveTaskChanges,
+    getTask,
+    getColumn,
+    getColumnByTaskId
+  }
+}
\ No newline at end of file
diff --git a/types/kanban.ts b/types/kanban.ts
new file mode 100644
index 0000000..b624c9a
--- /dev/null
+++ b/types/kanban.ts
@@ -0,0 +1,32 @@
+export interface KanbanTask {
+  id: string;
+  title: string;
+  description: string;
+  status: 'todo' | 'in-progress' | 'done';
+  priority: 'low' | 'medium' | 'high';
+  assignee?: string;
+  createdAt: string;
+  updatedAt: string;
+  dueDate?: string;
+}
+
+export interface KanbanColumn {
+  id: string;
+  title: string;
+  status: 'todo' | 'in-progress' | 'done';
+  tasks: KanbanTask[];
+  maxTasks?: number;
+}
+
+export interface KanbanBoard {
+  id: string;
+  title: string;
+  description?: string;
+  columns: KanbanColumn[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface KanbanData {
+  boards: KanbanBoard[];
+}
\ No newline at end of file