diff --git a/src/Project/web.go b/src/Project/web.go
deleted file mode 100644
index d253c5b679492d3f00e46040d50deca211f81dfe..0000000000000000000000000000000000000000
--- a/src/Project/web.go
+++ /dev/null
@@ -1,493 +0,0 @@
-package web
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"net/http"
-	"time"
-
-	"github.com/org-harmony/harmony/src/app/project"
-	"github.com/org-harmony/harmony/src/app/user"
-	"github.com/org-harmony/harmony/src/core/hctx"
-	"github.com/org-harmony/harmony/src/core/validation"
-	"github.com/org-harmony/harmony/src/core/web"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-)
-
-// ProjectFormData represents the data structure needed for rendering project forms
-// This struct is used for both creating new projects and editing existing ones
-type ProjectFormData struct {
-	Project    any  // Can hold either *project.ProjectToCreate or *project.ProjectToUpdate
-	IsEditForm bool // Flag to determine if this is an edit form (true) or create form (false)
-}
-
-// ProjectListData contains the list of projects for template rendering
-// This structure is passed to the project list template
-type ProjectListData struct {
-	Projects []*project.Project // Array of all projects belonging to a user
-}
-
-// ProjectDetailData holds all necessary data for displaying detailed project information
-// including tab navigation and requirement management
-type ProjectDetailData struct {
-	Project             *project.ProjectWithRequirements // The project with all its requirements loaded
-	ActiveTab           string                           // Currently active tab: "general" or "requirements"
-	RequirementStatuses []string                         // Available status options for requirements
-}
-
-// RegisterController sets up all HTTP routes and handlers for project management
-// This function is called during application startup to configure the web routing
-func RegisterController(appCtx *hctx.AppCtx, webCtx *web.Ctx, mongoManager *project.MongoManager) {
-	log.Println("INFO: Registering project controllers...")
-
-	// Initialize the data access layer (repository) and business logic layer (service)
-	// Repository handles MongoDB operations, Service handles business rules
-	projectRepo := project.NewMongoProjectRepository(mongoManager.GetDatabase())
-	projectService := project.NewProjectService(projectRepo)
-	log.Println("INFO: Project repository and service initialized")
-
-	// Create a router group that requires user authentication
-	// All routes defined here will require a logged-in user
-	router := webCtx.Router.With(user.LoggedInMiddleware(appCtx))
-
-	// Define all HTTP routes for project management:
-
-	// GET /project/list - Display all projects for the current user
-	router.Get("/project/list", projectListController(appCtx, webCtx, projectService).ServeHTTP)
-
-	// GET /project/new - Show form for creating a new project
-	router.Get("/project/new", projectNewController(appCtx, webCtx).ServeHTTP)
-
-	// POST /project/new - Process new project creation form submission
-	router.Post("/project/new", projectCreateController(appCtx, webCtx, projectService).ServeHTTP)
-
-	// GET /project/{id} - Display detailed view of a specific project
-	router.Get("/project/{id}", projectDetailController(appCtx, webCtx, projectService).ServeHTTP)
-
-	// GET /project/{id}/edit - Show form for editing an existing project
-	router.Get("/project/{id}/edit", projectEditFormController(appCtx, webCtx, projectService).ServeHTTP)
-
-	// PUT /project/{id} - Process project update form submission
-	router.Put("/project/{id}", projectUpdateController(appCtx, webCtx, projectService).ServeHTTP)
-
-	// DELETE /project/{id} - Delete a project and all its requirements
-	router.Delete("/project/{id}", projectDeleteController(appCtx, webCtx, projectService).ServeHTTP)
-
-	// POST /project/search - Handle project search functionality
-	router.Post("/project/search", projectSearchController(appCtx, webCtx, projectService).ServeHTTP)
-
-	log.Println("INFO: Project routes registered successfully")
-}
-
-// projectListController handles requests to display all projects belonging to the current user
-// This controller fetches projects from the database and renders them in a list view
-func projectListController(appCtx *hctx.AppCtx, webCtx *web.Ctx, service *project.ProjectService) http.Handler {
-	return web.NewController(appCtx, webCtx, func(io web.IO) error {
-		ctx := io.Context()
-		// Extract the currently logged-in user from the request context
-		// This user information was added by the authentication middleware
-		usr := user.MustCtxUser(ctx)
-
-		log.Printf("INFO: Loading project list for user %s", usr.ID)
-
-		// Fetch all projects created by this user from the database
-		// This calls through the service layer to maintain separation of concerns
-		projects, err := service.GetProjectsByUser(ctx, usr.ID)
-		if err != nil {
-			log.Printf("ERROR: Failed to get projects for user %s: %v", usr.ID, err)
-			return io.Error(web.ErrInternal, err)
-		}
-
-		log.Printf("INFO: Found %d projects for user %s", len(projects), usr.ID)
-
-		// Prepare data structure for template rendering
-		data := ProjectListData{Projects: projects}
-		log.Printf("DEBUG: Rendering project list with %d projects", len(data.Projects))
-
-		// Render the template with the project data
-		// The template system will wrap this data in BaseTemplateData automatically
-		err = io.Render(
-			data,
-			"project.list.page",         // Template name to execute
-			"project/list-page.go.html", // Main page template file
-			"project/_list.go.html",     // Partial template for the project list
-		)
-
-		if err != nil {
-			log.Printf("ERROR: Failed to render project list: %v", err)
-			return err
-		}
-
-		log.Println("INFO: Project list rendered successfully")
-		return nil
-	})
-}
-
-// projectNewController displays an empty form for creating a new project
-// This controller prepares default values and renders the project creation form
-func projectNewController(appCtx *hctx.AppCtx, webCtx *web.Ctx) http.Handler {
-	return web.NewController(appCtx, webCtx, func(io web.IO) error {
-		log.Println("INFO: Showing new project form")
-
-		// Create a new project structure with sensible default values
-		// Start date is today, end date is 6 months in the future
-		toCreate := &project.ProjectToCreate{
-			StartDate: time.Now(),
-			EndDate:   time.Now().AddDate(0, 6, 0), // Add 6 months to current date
-		}
-
-		// Render the project form with empty/default values
-		return renderProjectForm(io, &ProjectFormData{
-			Project:    toCreate,
-			IsEditForm: false, // This is a creation form, not an edit form
-		}, nil, nil)
-	})
-}
-
-// projectCreateController processes the form submission for creating a new project
-// This controller validates the input, creates the project, and handles success/error cases
-func projectCreateController(appCtx *hctx.AppCtx, webCtx *web.Ctx, service *project.ProjectService) http.Handler {
-	return web.NewController(appCtx, webCtx, func(io web.IO) error {
-		ctx := io.Context()
-		// Get the current user to associate the new project with them
-		usr := user.MustCtxUser(ctx)
-
-		log.Printf("INFO: Creating new project for user %s", usr.ID)
-
-		// Initialize a new project creation object with the user ID
-		toCreate := &project.ProjectToCreate{CreatedBy: usr.ID}
-
-		// Parse and validate the form data from the HTTP request
-		// This extracts form fields and validates them against defined rules
-		err, validationErrs := web.ReadForm(io.Request(), toCreate, appCtx.Validator)
-		if err != nil {
-			log.Printf("ERROR: Failed to read project form: %v", err)
-			return io.Error(web.ErrInternal, err)
-		}
-
-		// If there are validation errors, redisplay the form with error messages
-		if validationErrs != nil {
-			log.Printf("WARN: Project creation validation failed: %d errors", len(validationErrs))
-			return renderProjectForm(io, &ProjectFormData{
-				Project:    toCreate,
-				IsEditForm: false,
-			}, nil, validationErrs)
-		}
-
-		log.Printf("INFO: Creating project with ID '%s' and name '%s'", toCreate.ProjectID, toCreate.Name)
-
-		// Attempt to create the project using the business logic service
-		// The service will handle additional validation and database operations
-		newProject, err := service.CreateProject(ctx, toCreate)
-		if err != nil {
-			log.Printf("ERROR: Failed to create project '%s': %v", toCreate.ProjectID, err)
-			// If creation fails, redisplay the form with the error message
-			return renderProjectForm(io, &ProjectFormData{
-				Project:    toCreate,
-				IsEditForm: false,
-			}, nil, []error{validation.Error{Msg: err.Error()}})
-		}
-
-		log.Printf("INFO: Project '%s' created successfully with MongoDB ID %s", newProject.ProjectID, newProject.ID.Hex())
-
-		// On successful creation, redirect to the project detail page
-		return io.Redirect(fmt.Sprintf("/project/%s", newProject.ID.Hex()), http.StatusFound)
-	})
-}
-
-// projectDetailController displays detailed information about a specific project
-// This includes general project info and requirements, organized in tabs
-func projectDetailController(appCtx *hctx.AppCtx, webCtx *web.Ctx, service *project.ProjectService) http.Handler {
-	return web.NewController(appCtx, webCtx, func(io web.IO) error {
-		ctx := io.Context()
-
-		// Extract the project ID from the URL parameters
-		id, err := parseObjectID(io.Request(), "id")
-		if err != nil {
-			log.Printf("ERROR: Invalid project ID in URL: %v", err)
-			return io.Error(web.ErrInternal, err)
-		}
-
-		log.Printf("INFO: Loading project details for ID %s", id.Hex())
-
-		// Fetch the project along with all its requirements from the database
-		// This is more efficient than making separate calls for project and requirements
-		projectWithReqs, err := service.GetProjectWithRequirements(ctx, id)
-		if err != nil {
-			log.Printf("ERROR: Failed to get project with requirements for ID %s: %v", id.Hex(), err)
-			return io.Error(web.ErrInternal, err)
-		}
-
-		// Determine which tab should be active (from URL query parameter)
-		// Default to "general" tab if no tab is specified
-		activeTab := io.Request().URL.Query().Get("tab")
-		if activeTab == "" {
-			activeTab = "general"
-		}
-
-		log.Printf("INFO: Loaded project '%s' with %d requirements, showing tab '%s'",
-			projectWithReqs.Project.Name, projectWithReqs.RequirementCount, activeTab)
-
-		// Prepare all data needed for the project detail template
-		data := ProjectDetailData{
-			Project:             projectWithReqs,
-			ActiveTab:           activeTab,
-			RequirementStatuses: []string{"Entwurf", "In Prüfung", "Genehmigt", "Abgelehnt"}, // Available status options
-		}
-
-		// Render the project detail page with multiple template files
-		err = io.Render(
-			data,
-			"project.detail.page",                          // Main template name
-			"templates/project/detail-page.go.html",        // Page wrapper template
-			"templates/project/_detail.go.html",            // Project detail content
-			"templates/project/_requirements-list.go.html", // Requirements list partial
-		)
-
-		if err != nil {
-			log.Printf("ERROR: Failed to render project detail page: %v", err)
-			return err
-		}
-
-		log.Println("INFO: Project detail page rendered successfully")
-		return nil
-	})
-}
-
-// projectEditFormController displays a form pre-filled with existing project data for editing
-// This controller loads the current project data and renders it in an editable form
-func projectEditFormController(appCtx *hctx.AppCtx, webCtx *web.Ctx, service *project.ProjectService) http.Handler {
-	return web.NewController(appCtx, webCtx, func(io web.IO) error {
-		ctx := io.Context()
-
-		// Parse the project ID from the URL
-		id, err := parseObjectID(io.Request(), "id")
-		if err != nil {
-			log.Printf("ERROR: Invalid project ID for edit: %v", err)
-			return io.InlineError(web.ErrInternal, err)
-		}
-
-		log.Printf("INFO: Loading project edit form for ID %s", id.Hex())
-
-		// Get all projects for the current user to find the requested project
-		// This ensures the user can only edit their own projects
-		proj, err := service.GetProjectsByUser(ctx, user.MustCtxUser(ctx).ID)
-		if err != nil {
-			log.Printf("ERROR: Failed to get projects for edit: %v", err)
-			return io.InlineError(web.ErrInternal, err)
-		}
-
-		// Search through the user's projects to find the one being edited
-		var targetProject *project.Project
-		for _, p := range proj {
-			if p.ID == id {
-				targetProject = p
-				break
-			}
-		}
-
-		// If the project is not found, it either doesn't exist or doesn't belong to this user
-		if targetProject == nil {
-			log.Printf("ERROR: Project with ID %s not found for edit", id.Hex())
-			return io.InlineError(web.ErrInternal, errors.New("project not found"))
-		}
-
-		log.Printf("INFO: Showing edit form for project '%s'", targetProject.Name)
-
-		// Convert the project to an update structure and render the edit form
-		return renderProjectEditForm(io, targetProject.ToUpdate(), nil, nil)
-	})
-}
-
-// projectUpdateController processes form submissions for updating existing projects
-// This controller validates changes and applies them to the database
-func projectUpdateController(appCtx *hctx.AppCtx, webCtx *web.Ctx, service *project.ProjectService) http.Handler {
-	return web.NewController(appCtx, webCtx, func(io web.IO) error {
-		ctx := io.Context()
-
-		// Extract project ID from URL parameters
-		id, err := parseObjectID(io.Request(), "id")
-		if err != nil {
-			log.Printf("ERROR: Invalid project ID for update: %v", err)
-			return io.InlineError(web.ErrInternal, err)
-		}
-
-		log.Printf("INFO: Updating project with ID %s", id.Hex())
-
-		// Create an update structure with the project ID
-		toUpdate := &project.ProjectToUpdate{ID: id}
-
-		// Parse and validate the form data from the request
-		err, validationErrs := web.ReadForm(io.Request(), toUpdate, appCtx.Validator)
-		if err != nil {
-			log.Printf("ERROR: Failed to read update form: %v", err)
-			return io.InlineError(web.ErrInternal, err)
-		}
-
-		// If validation fails, redisplay the form with error messages
-		if validationErrs != nil {
-			log.Printf("WARN: Project update validation failed: %d errors", len(validationErrs))
-			return renderProjectEditForm(io, toUpdate, nil, validationErrs)
-		}
-
-		log.Printf("INFO: Updating project '%s' with new name '%s'", id.Hex(), toUpdate.Name)
-
-		// Apply the updates through the service layer
-		updatedProject, err := service.UpdateProject(ctx, toUpdate)
-		if err != nil {
-			log.Printf("ERROR: Failed to update project %s: %v", id.Hex(), err)
-			return renderProjectEditForm(io, toUpdate, nil, []error{validation.Error{Msg: err.Error()}})
-		}
-
-		log.Printf("INFO: Project '%s' updated successfully", updatedProject.Name)
-
-		// Redisplay the form with a success message
-		return renderProjectEditForm(io, updatedProject.ToUpdate(), []string{"Projekt erfolgreich aktualisiert"}, nil)
-	})
-}
-
-// projectDeleteController handles project deletion requests
-// This controller removes the project and all associated requirements from the database
-func projectDeleteController(appCtx *hctx.AppCtx, webCtx *web.Ctx, service *project.ProjectService) http.Handler {
-	return web.NewController(appCtx, webCtx, func(io web.IO) error {
-		ctx := io.Context()
-		usr := user.MustCtxUser(ctx)
-
-		// Parse the project ID from the URL
-		id, err := parseObjectID(io.Request(), "id")
-		if err != nil {
-			log.Printf("ERROR: Invalid project ID for deletion: %v", err)
-			return io.InlineError(web.ErrInternal, err)
-		}
-
-		log.Printf("INFO: Deleting project with ID %s for user %s", id.Hex(), usr.ID)
-
-		// Delete the project and all its requirements through the service
-		err = service.DeleteProject(ctx, id)
-		if err != nil {
-			log.Printf("ERROR: Failed to delete project %s: %v", id.Hex(), err)
-			return io.InlineError(web.ErrInternal, err)
-		}
-
-		log.Printf("INFO: Project %s deleted successfully", id.Hex())
-
-		// After deletion, fetch and return the updated project list
-		// This provides immediate feedback to the user about the deletion
-		projects, err := service.GetProjectsByUser(ctx, usr.ID)
-		if err != nil {
-			log.Printf("ERROR: Failed to get updated project list after deletion: %v", err)
-			return io.InlineError(web.ErrInternal, err)
-		}
-
-		log.Printf("INFO: Returning updated project list with %d projects", len(projects))
-
-		// Return the updated project list as HTML to replace the current list
-		data := ProjectListData{Projects: projects}
-		return io.Render(
-			data,
-			"project.list",          // Template name for just the list part
-			"project/_list.go.html", // Partial template for project list
-		)
-	})
-}
-
-// projectSearchController handles search requests for projects
-// This controller filters projects based on user input and returns matching results
-func projectSearchController(appCtx *hctx.AppCtx, webCtx *web.Ctx, service *project.ProjectService) http.Handler {
-	return web.NewController(appCtx, webCtx, func(io web.IO) error {
-		ctx := io.Context()
-		usr := user.MustCtxUser(ctx)
-
-		request := io.Request()
-
-		// Parse the form data to extract search parameters
-		err := request.ParseForm()
-		if err != nil {
-			log.Printf("ERROR: Failed to parse search form: %v", err)
-			return io.InlineError(web.ErrInternal, err)
-		}
-
-		// Extract the search query from the form
-		query := request.FormValue("search")
-		log.Printf("INFO: Searching projects for user %s with query '%s'", usr.ID, query)
-
-		// Perform the search using the service layer
-		// The service handles both empty queries (return all) and actual searches
-		projects, err := service.SearchProjects(ctx, query, usr.ID)
-		if err != nil {
-			log.Printf("ERROR: Project search failed for query '%s': %v", query, err)
-			return io.InlineError(web.ErrInternal, err)
-		}
-
-		log.Printf("INFO: Search found %d projects for query '%s'", len(projects), query)
-
-		// Return the search results as a partial HTML update
-		data := ProjectListData{Projects: projects}
-		return io.Render(
-			data,
-			"project.list",                    // Template name for the list
-			"templates/project/_list.go.html", // Partial template file
-		)
-	})
-}
-
-// Helper Functions
-
-// parseObjectID extracts and validates a MongoDB ObjectID from HTTP request parameters
-// This function ensures that URL parameters containing IDs are valid MongoDB ObjectIDs
-func parseObjectID(r *http.Request, param string) (primitive.ObjectID, error) {
-	// Extract the parameter value from the URL
-	idStr := web.URLParam(r, param)
-	if idStr == "" {
-		return primitive.NilObjectID, errors.New("missing id parameter")
-	}
-
-	// Convert the string to a valid MongoDB ObjectID
-	return primitive.ObjectIDFromHex(idStr)
-}
-
-// renderProjectForm is a helper function to render project creation/edit forms
-// This function handles both success messages and validation errors
-func renderProjectForm(io web.IO, data *ProjectFormData, success []string, errs []error) error {
-	log.Printf("DEBUG: Rendering project form (edit=%t, errors=%d)", data.IsEditForm, len(errs))
-
-	// Wrap the form data with success messages and errors for template rendering
-	err := io.Render(
-		web.NewFormData(data, success, errs...),
-		"project.form.page",         // Main template name
-		"project/form-page.go.html", // Page wrapper template
-		"project/_form.go.html",     // Form partial template
-	)
-
-	if err != nil {
-		log.Printf("ERROR: Failed to render project form: %v", err)
-	}
-
-	return err
-}
-
-// renderProjectEditForm is a specialized helper for rendering edit forms
-// This function prepares edit-specific form data and renders the appropriate templates
-func renderProjectEditForm(io web.IO, toUpdate *project.ProjectToUpdate, success []string, errs []error) error {
-	// Create form data structure specifically for editing
-	formData := &ProjectFormData{
-		Project:    toUpdate,
-		IsEditForm: true, // This flag helps the template render edit-specific elements
-	}
-
-	log.Printf("DEBUG: Rendering project edit form for project %s (errors=%d)", toUpdate.ID.Hex(), len(errs))
-
-	// Render the edit form with the current project data
-	err := io.Render(
-		web.NewFormData(formData, success, errs...),
-		"project.edit.form",     // Template name for edit forms
-		"project/_form.go.html", // Shared form partial template
-	)
-
-	if err != nil {
-		log.Printf("ERROR: Failed to render project edit form: %v", err)
-	}
-
-	return err
-}
diff --git a/src/Project/web/web.go b/src/Project/web/web.go
index d253c5b679492d3f00e46040d50deca211f81dfe..198aff1e64ff14e07a472e95cdc3ba65d93d5a49 100644
--- a/src/Project/web/web.go
+++ b/src/Project/web/web.go
@@ -7,7 +7,6 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/org-harmony/harmony/src/app/project"
 	"github.com/org-harmony/harmony/src/app/user"
 	"github.com/org-harmony/harmony/src/core/hctx"
 	"github.com/org-harmony/harmony/src/core/validation"