diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
index 356254a4..e9aeba6a 100644
--- a/src/main/java/module-info.java
+++ b/src/main/java/module-info.java
@@ -48,6 +48,7 @@
     opens org.chainoptim.desktop.core.organization.controller to javafx.fxml, com.google.guice;
     opens org.chainoptim.desktop.core.organization.service to com.google.guice;
     opens org.chainoptim.desktop.core.organization.model to com.fasterxml.jackson.databind;
+    opens org.chainoptim.desktop.core.organization.dto to com.fasterxml.jackson.databind;
 
     // Features
     // - Product
diff --git a/src/main/java/org/chainoptim/desktop/core/main/controller/OverviewController.java b/src/main/java/org/chainoptim/desktop/core/main/controller/OverviewController.java
index b39d1c16..54106db1 100644
--- a/src/main/java/org/chainoptim/desktop/core/main/controller/OverviewController.java
+++ b/src/main/java/org/chainoptim/desktop/core/main/controller/OverviewController.java
@@ -36,17 +36,13 @@ public void initialize(URL location, ResourceBundle resources) {
     }
 
     private void fetchAndSetUser(String username) {
-        try {
-            userService.getUserByUsername(username)
-                    .thenAcceptAsync(userOptional -> userOptional.ifPresentOrElse(this::updateCurrentUser,
-                            () -> Platform.runLater(() -> System.err.println("User not found."))))
-                    .exceptionally(ex -> {
-                        Platform.runLater(() -> System.err.println("Failed to load user: " + ex.getMessage()));
-                        return null;
-                    });
-        } catch (UnsupportedEncodingException e) {
-            throw new RuntimeException("Error encoding username: " + e.getMessage());
-        }
+        userService.getUserByUsername(username)
+                .thenAcceptAsync(userOptional -> userOptional.ifPresentOrElse(this::updateCurrentUser,
+                        () -> Platform.runLater(() -> System.err.println("User not found."))))
+                .exceptionally(ex -> {
+                    Platform.runLater(() -> System.err.println("Failed to load user: " + ex.getMessage()));
+                    return null;
+                });
     }
 
     private void updateCurrentUser(User user) {
diff --git a/src/main/java/org/chainoptim/desktop/core/organization/controller/ConfirmCustomRoleDeleteController.java b/src/main/java/org/chainoptim/desktop/core/organization/controller/ConfirmCustomRoleDeleteController.java
new file mode 100644
index 00000000..8230e25d
--- /dev/null
+++ b/src/main/java/org/chainoptim/desktop/core/organization/controller/ConfirmCustomRoleDeleteController.java
@@ -0,0 +1,81 @@
+package org.chainoptim.desktop.core.organization.controller;
+
+import org.chainoptim.desktop.core.organization.model.ConfirmDeleteDialogActionListener;
+import org.chainoptim.desktop.core.organization.model.ConfirmUpdateDialogActionListener;
+import org.chainoptim.desktop.core.organization.model.CustomRole;
+import org.chainoptim.desktop.core.user.model.User;
+import org.chainoptim.desktop.core.user.service.UserService;
+import org.chainoptim.desktop.shared.util.DataReceiver;
+import com.google.inject.Inject;
+import javafx.application.Platform;
+import javafx.fxml.FXML;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.VBox;
+import lombok.Setter;
+
+import java.util.List;
+import java.util.Optional;
+
+public class ConfirmCustomRoleDeleteController implements DataReceiver<Integer> {
+
+    private final UserService userService;
+
+    private Integer customRoleId;
+
+    @Setter
+    private ConfirmDeleteDialogActionListener actionListener;
+
+    @FXML
+    private VBox usersVBox;
+    @FXML
+    private Button confirmButton;
+    @FXML
+    private Button cancelButton;
+
+    @Inject
+    public ConfirmCustomRoleDeleteController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @Override
+    public void setData(Integer customRoleId) {
+        this.customRoleId = customRoleId;
+
+        userService.getUsersByCustomRoleId(customRoleId)
+                .thenApply(this::handleUsersResponse)
+                .exceptionally(this::handleUsersException);
+    }
+
+    private Optional<List<User>> handleUsersResponse(Optional<List<User>> users) {
+        if (users.isEmpty()) {
+            return Optional.empty();
+        }
+        Platform.runLater(() -> {
+            List<User> userList = users.get();
+            usersVBox.getChildren().clear();
+
+            for (User user : userList) {
+                // Put names into VBox
+                Label usernameLabel = new Label(user.getUsername());
+                usersVBox.getChildren().add(usernameLabel);
+            }
+        });
+        return users;
+    }
+
+    private Optional<List<User>> handleUsersException(Throwable ex) {
+        ex.printStackTrace();
+        return Optional.empty();
+    }
+
+    @FXML
+    private void onConfirmButtonClicked() {
+        actionListener.onConfirmCustomRoleDelete(customRoleId);
+    }
+
+    @FXML
+    private void onCancelButtonClicked() {
+        actionListener.onCancelCustomRoleDelete();
+    }
+}
diff --git a/src/main/java/org/chainoptim/desktop/core/organization/controller/ConfirmCustomRoleUpdateController.java b/src/main/java/org/chainoptim/desktop/core/organization/controller/ConfirmCustomRoleUpdateController.java
new file mode 100644
index 00000000..e96d30df
--- /dev/null
+++ b/src/main/java/org/chainoptim/desktop/core/organization/controller/ConfirmCustomRoleUpdateController.java
@@ -0,0 +1,80 @@
+package org.chainoptim.desktop.core.organization.controller;
+
+import org.chainoptim.desktop.core.organization.model.ConfirmUpdateDialogActionListener;
+import org.chainoptim.desktop.core.organization.model.CustomRole;
+import org.chainoptim.desktop.core.user.model.User;
+import org.chainoptim.desktop.core.user.service.UserService;
+import org.chainoptim.desktop.shared.util.DataReceiver;
+import com.google.inject.Inject;
+import javafx.application.Platform;
+import javafx.fxml.FXML;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.VBox;
+import lombok.Setter;
+
+import java.util.List;
+import java.util.Optional;
+
+public class ConfirmCustomRoleUpdateController implements DataReceiver<CustomRole> {
+
+    private final UserService userService;
+
+    private CustomRole customRole;
+
+    @Setter
+    private ConfirmUpdateDialogActionListener confirmUpdateDialogActionListener;
+
+    @FXML
+    private VBox usersVBox;
+    @FXML
+    private Button confirmButton;
+    @FXML
+    private Button cancelButton;
+
+    @Inject
+    public ConfirmCustomRoleUpdateController(UserService userService) {
+        this.userService = userService;
+    }
+
+    @Override
+    public void setData(CustomRole data) {
+        this.customRole = data;
+        System.out.println("Custom role: " + customRole.getName());
+
+        userService.getUsersByCustomRoleId(customRole.getId())
+                .thenApply(this::handleUsersResponse)
+                .exceptionally(this::handleUsersException);
+    }
+
+    private Optional<List<User>> handleUsersResponse(Optional<List<User>> users) {
+        if (users.isEmpty()) {
+            System.out.println("No users found for custom role: " + customRole.getName());
+            return Optional.empty();
+        }
+        Platform.runLater(() -> {
+            List<User> userList = users.get();
+            for (User user : userList) {
+                // Put names into VBox
+                Label usernameLabel = new Label(user.getUsername());
+                usersVBox.getChildren().add(usernameLabel);
+            }
+        });
+        return users;
+    }
+
+    private Optional<List<User>> handleUsersException(Throwable ex) {
+        ex.printStackTrace();
+        return Optional.empty();
+    }
+
+    @FXML
+    private void onConfirmButtonClicked() {
+        confirmUpdateDialogActionListener.onConfirmCustomRoleUpdate(customRole);
+    }
+
+    @FXML
+    private void onCancelButtonClicked() {
+        confirmUpdateDialogActionListener.onCancelCustomRoleUpdate();
+    }
+}
diff --git a/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationController.java b/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationController.java
index b98f7976..27e2df53 100644
--- a/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationController.java
+++ b/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationController.java
@@ -167,8 +167,7 @@ private Optional<Organization> handleOrganizationException(Throwable ex) {
     }
 
     @FXML
-    private void handleChangePlan() {
-
-        loadTabContent(subscriptionPlanTab, "/org/chainoptim/desktop/core/organization/OrganizationSubscriptionPlanView.fxml", this.organization);
+    private void handleEditOrganization() {
+        System.out.println("Edit organization clicked");
     }
 }
diff --git a/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationCustomRolesController.java b/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationCustomRolesController.java
index 6b4c26c6..88a81f38 100644
--- a/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationCustomRolesController.java
+++ b/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationCustomRolesController.java
@@ -1,87 +1,160 @@
 package org.chainoptim.desktop.core.organization.controller;
 
+import org.chainoptim.desktop.core.abstraction.ControllerFactory;
+import org.chainoptim.desktop.core.organization.dto.CreateCustomRoleDTO;
 import org.chainoptim.desktop.core.organization.dto.UpdateCustomRoleDTO;
-import org.chainoptim.desktop.core.organization.model.CustomRole;
-import org.chainoptim.desktop.core.organization.model.FeaturePermissions;
-import org.chainoptim.desktop.core.organization.model.Organization;
-import org.chainoptim.desktop.core.organization.model.Permissions;
+import org.chainoptim.desktop.core.organization.model.*;
 import org.chainoptim.desktop.core.organization.service.CustomRoleService;
 import org.chainoptim.desktop.shared.fallback.FallbackManager;
 import org.chainoptim.desktop.shared.util.DataReceiver;
+import org.chainoptim.desktop.shared.util.resourceloader.FXMLLoaderService;
 
 import com.google.inject.Inject;
 import javafx.application.Platform;
 import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
 import javafx.geometry.HPos;
 import javafx.geometry.Insets;
 import javafx.scene.Node;
-import javafx.scene.control.Button;
-import javafx.scene.control.CheckBox;
-import javafx.scene.control.Control;
-import javafx.scene.control.Label;
+import javafx.scene.control.*;
 import javafx.scene.image.Image;
 import javafx.scene.image.ImageView;
-import javafx.scene.layout.ColumnConstraints;
 import javafx.scene.layout.GridPane;
-import javafx.scene.layout.Region;
-import javafx.scene.layout.RowConstraints;
+import javafx.scene.layout.StackPane;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 
-public class OrganizationCustomRolesController implements DataReceiver<Organization> {
+public class OrganizationCustomRolesController implements DataReceiver<Organization>, ConfirmUpdateDialogActionListener, ConfirmDeleteDialogActionListener {
 
+    // Injected services and controllers
     private final CustomRoleService customRoleService;
-
+    private final FXMLLoaderService fxmlLoaderService;
+    private final ControllerFactory controllerFactory;
     private final FallbackManager fallbackManager;
 
-    private Organization organization;
-    private List<CustomRole> customRoles;
+    private ConfirmCustomRoleUpdateController confirmCustomRoleUpdateController;
+    private ConfirmCustomRoleDeleteController confirmCustomRoleDeleteController;
 
+    // FXML
+    @FXML
+    private Label tabTitle;
+    @FXML
+    private Button addNewRoleButton;
+    @FXML
+    private Button deleteRoleButton;
     @FXML
     private GridPane customRolesPane;
     @FXML
     private List<Button> expandRoleButtons = new ArrayList<>();
+    @FXML
+    private StackPane confirmUpdateDialogContainer;
+    @FXML
+    private StackPane confirmDeleteDialogContainer;
 
+    // State
+    private Organization organization;
+    private List<CustomRole> customRoles;
     private final List<Boolean> expandedRoleStates = new ArrayList<>();
-    private final boolean editRoleState = false;
+    private int currentEditedRowIndex = -1; // No edit marker
+    private boolean isDeleteMode = false;
+    private int currentToBeDeletedRowIndex = -1;
 
+    // Constants
     private static final String[] operations = {"Read", "Create", "Update", "Delete"};
     private static final String[] features = {"Products", "Factories", "Warehouses", "Suppliers", "Clients"};
 
+    // Icons
+    private Image plusImage;
+    private Image trashImage;
     private Image angleUpImage;
     private Image angleDownImage;
     private Image editImage;
     private Image saveImage;
+    private Image cancelImage;
 
     @Inject
     public OrganizationCustomRolesController(CustomRoleService customRoleService,
+                                             FXMLLoaderService fxmlLoaderService,
+                                             ControllerFactory controllerFactory,
                                              FallbackManager fallbackManager) {
         this.customRoleService = customRoleService;
+        this.fxmlLoaderService = fxmlLoaderService;
+        this.controllerFactory = controllerFactory;
         this.fallbackManager = fallbackManager;
     }
 
     @Override
     public void setData(Organization data) {
         this.organization = data;
-        fallbackManager.reset();
-        fallbackManager.setLoading(true);
+        if (organization == null) {
+            fallbackManager.setNoOrganization(true);
+            return;
+        }
 
         initializeIcons();
+        loadConfirmUpdateDialog();
+        loadConfirmDeleteDialog();
 
-        customRoleService.getCustomRolesByOrganizationId(organization.getId())
-                .thenApply(this::handleCustomRolesResponse)
-                .exceptionally(this::handleCustomRolesException)
-                .thenRun(() -> Platform.runLater(() -> fallbackManager.setLoading(false)));
+        loadCustomRoles();
     }
 
+    // Initialize UI
     private void initializeIcons() {
+        plusImage = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/img/plus.png")));
+        trashImage = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/img/trash-solid.png")));
         angleUpImage = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/img/angle-up-solid.png")));
         angleDownImage = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/img/angle-down-solid.png")));
         editImage = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/img/pen-to-square-solid.png")));
         saveImage = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/img/floppy-disk-solid.png")));
+        cancelImage = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/img/xmark-solid.png")));
+    }
+
+    private void loadConfirmUpdateDialog() {
+        // Load view into fallbackContainer
+        FXMLLoader loader = fxmlLoaderService.setUpLoader(
+                "/org/chainoptim/desktop/core/organization/ConfirmCustomRoleUpdateView.fxml",
+                controllerFactory::createController
+        );
+        try {
+            Node confirmDialogView = loader.load();
+            confirmCustomRoleUpdateController = loader.getController();
+            confirmCustomRoleUpdateController.setConfirmUpdateDialogActionListener(this); // Listen to confirm dialog actions
+            confirmUpdateDialogContainer.getChildren().add(confirmDialogView);
+            closeConfirmUpdateDialog(); // Start hidden
+        } catch (IOException ex) {
+            ex.printStackTrace();
+        }
+    }
+    private void loadConfirmDeleteDialog() {
+        // Load view into fallbackContainer
+        FXMLLoader loader = fxmlLoaderService.setUpLoader(
+                "/org/chainoptim/desktop/core/organization/ConfirmCustomRoleDeleteView.fxml",
+                controllerFactory::createController
+        );
+        try {
+            Node confirmDialogView = loader.load();
+            confirmCustomRoleDeleteController = loader.getController();
+            confirmCustomRoleDeleteController.setActionListener(this); // Listen to confirm dialog actions
+            confirmDeleteDialogContainer.getChildren().add(confirmDialogView);
+            closeConfirmDeleteDialog(); // Start hidden
+        } catch (IOException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    // Load roles
+    private void loadCustomRoles() {
+        fallbackManager.reset();
+        fallbackManager.setLoading(true);
+
+        customRoleService.getCustomRolesByOrganizationId(organization.getId())
+                .thenApply(this::handleCustomRolesResponse)
+                .exceptionally(this::handleCustomRolesException)
+                .thenRun(() -> Platform.runLater(() -> fallbackManager.setLoading(false)));
     }
 
     private Optional<List<CustomRole>> handleCustomRolesResponse(Optional<List<CustomRole>> customRolesOptional) {
@@ -92,6 +165,12 @@ private Optional<List<CustomRole>> handleCustomRolesResponse(Optional<List<Custo
             }
             customRoles = customRolesOptional.get();
 
+            tabTitle.setText("Custom Roles (" + customRoles.size() + ")");
+            styleDeleteRoleButton(deleteRoleButton);
+            deleteRoleButton.setOnAction(event -> toggleDeleteMode());
+            styleAddNewRoleButton(addNewRoleButton);
+            addNewRoleButton.setOnAction(event -> handleAddNewRole());
+
             // Render the grid
             renderGridPane();
         });
@@ -103,14 +182,21 @@ private Optional<List<CustomRole>> handleCustomRolesException(Throwable ex) {
         return Optional.empty();
     }
 
+    /*
+     * Grid Layout:
+     * C. Role 1 | Read | Create | Update | Delete | Expand | Edit/Cancel | Save | Delete
+     * Feature 1 | Read | Create | Update | Delete
+     * Feature 2 | Read | Create | Update | Delete
+     * ...
+     */
     private void renderGridPane() {
         customRolesPane.getChildren().clear();
 
-        Label customRoleLabel = new Label("Custom Role");
+        // Headers
+        Label customRoleLabel = new Label("Role Name");
         customRoleLabel.getStyleClass().add("column-header");
         customRolesPane.add(customRoleLabel, 0, 0);
 
-        // Headers
         for (int i = 0; i < operations.length; i++) {
             Label operationLabel = new Label(operations[i]);
             operationLabel.getStyleClass().add("column-header");
@@ -132,36 +218,39 @@ private void renderGridPane() {
     }
 
     private void addRoleRow(CustomRole role, int rowIndex) {
+        // Add row name label
         Label roleNameLabel = new Label(role.getName());
         roleNameLabel.getStyleClass().add("parent-row");
         customRolesPane.add(roleNameLabel, 0, rowIndex);
 
+        // Add row buttons
         addExpandButton(role, rowIndex);
         addEditButton(rowIndex);
-        addSaveButton(role, rowIndex);
+        addSaveButton(rowIndex);
+        addDeleteButton(role, rowIndex);
 
         // Add aggregate checkboxes
         for (int col = 0; col < operations.length; col++) {
             CheckBox checkBox = new CheckBox();
-            checkBox.setSelected(aggregatePermissionsByIndex(role.getPermissions(), col)); // Select if all underlying permissions are true
+            checkBox.setSelected(aggregatePermissionsByIndex(role.getPermissions(), col)); // Select if all the operation's permissions are true
             checkBox.setMouseTransparent(true);
             checkBox.setFocusTraversable(false);
             applyStandardMargin(checkBox);
+            int finalCol = col;
+            checkBox.setOnAction(event -> toggleOperationCheckboxes(rowIndex, finalCol, checkBox.isSelected())); // Toggle all the operation's permissions
             customRolesPane.add(checkBox, col + 1, rowIndex);
         }
     }
 
-    private void addExpandButton(CustomRole role, int rowIndex) {
-        Button expandButton = new Button();
-        expandButton.setGraphic(createImageView(angleDownImage));
-        expandButton.getStyleClass().add("no-style-button");
-        applyStandardMargin(expandButton);
+    private void toggleOperationCheckboxes(int rowIndex, int colIndex, boolean isSelected) {
+        if (rowIndex != currentEditedRowIndex) return; // Only allow toggling when in edit mode
 
-        expandButton.setOnAction(event -> toggleFeaturePermissions(role, rowIndex));
-
-        expandRoleButtons.add(expandButton);
-        expandedRoleStates.add(false); // Start from collapsed state
-        customRolesPane.add(expandButton, operations.length + 1, rowIndex);
+        for (int row = 1; row < features.length + 1; row++) {
+            Node node = getNodeByRowColumnIndex(rowIndex + row, colIndex + 1);
+            if (node instanceof CheckBox checkBox) {
+                checkBox.setSelected(isSelected);
+            }
+        }
     }
 
     private void addFeaturePermissionRow(String feature, CustomRole role, int rowIndex) {
@@ -172,7 +261,7 @@ private void addFeaturePermissionRow(String feature, CustomRole role, int rowInd
             if (col == 0) {
                 node = new Label(feature);
             } else {
-                boolean hasPermission = getPermissionByIndex(featurePermissions, col - 1);
+                boolean hasPermission = getPermissionByColumnIndex(featurePermissions, col - 1);
                 CheckBox checkBox = new CheckBox();
                 checkBox.setSelected(hasPermission);
                 checkBox.setMouseTransparent(true);
@@ -188,6 +277,19 @@ private void addFeaturePermissionRow(String feature, CustomRole role, int rowInd
         }
     }
 
+    // Buttons and their actions
+    // - Expand
+    private void addExpandButton(CustomRole role, int rowIndex) {
+        Button expandButton = new Button();
+        styleExpandButton(expandButton);
+
+        expandButton.setOnAction(event -> toggleFeaturePermissions(role, rowIndex));
+
+        expandRoleButtons.add(expandButton);
+        expandedRoleStates.add(false); // Start from collapsed state
+        customRolesPane.add(expandButton, operations.length + 1, rowIndex);
+    }
+
     private void toggleFeaturePermissions(CustomRole role, int roleVisualRowIndex) {
         int roleIndex = customRoles.indexOf(role);
         boolean isExpanded = expandedRoleStates.get(roleIndex);
@@ -213,28 +315,68 @@ private void toggleSubrowVisibility(int rowIndex, boolean isVisible) {
                 });
     }
 
+    // - Edit
     private void addEditButton(int rowIndex) {
+        System.out.println("Adding edit button to row " + rowIndex);
         Button editButton = new Button();
-        editButton.setGraphic(createImageView(editImage));
-        editButton.getStyleClass().add("standard-write-button");
+        styleEditButton(editButton);
 
         editButton.setOnAction(event -> toggleEditingRow(rowIndex, true));
 
         customRolesPane.add(editButton, operations.length + 2, rowIndex);
     }
 
-    private void toggleEditingRow(int roleVisualRowIndex, boolean isEdit) {
-        if (editRoleState) return; // Only allow one row to be edited at a time
+    private void toggleEditingRow(int rowIndex, boolean isEdit) {
+        if (isEdit) currentEditedRowIndex = rowIndex;
+
+        // Toggle role name between Label and TextField
+        toggleRoleName(rowIndex, isEdit);
 
         // Enable row checkboxes
-        toggleRowEdit(roleVisualRowIndex, isEdit);
+        toggleRowEdit(rowIndex, isEdit);
 
         // Enable subrow checkboxes
-        int rowIndex = roleVisualRowIndex + 1;
+        int featureRowIndex = rowIndex + 1;
         int featureRowsCount = features.length;
 
-        for (int i = 0; i < featureRowsCount; i++, rowIndex++) {
-            toggleRowEdit(rowIndex, isEdit);
+        for (int i = 0; i < featureRowsCount; i++, featureRowIndex++) {
+            toggleRowEdit(featureRowIndex, isEdit);
+        }
+
+        // Hide all edit buttons except the one being edited, show cancel button
+        for (int row = 0; row < customRoles.size(); row++) {
+            int realIndex = row * (featureRowsCount + 1) + 1;
+            Node editButtonNode = getNodeByRowColumnIndex(realIndex, operations.length + 2);
+
+            if (editButtonNode instanceof Button editButton) {
+                if (realIndex == rowIndex) {
+                    toggleEditCancelButton(editButton, rowIndex, isEdit);
+                } else {
+                    editButton.setVisible(!isEdit);
+                }
+            }
+        }
+
+        // Show save button in edit mode
+        Node saveButtonNode = getNodeByRowColumnIndex(rowIndex, operations.length + 3);
+        if (saveButtonNode instanceof Button saveButton) {
+            saveButton.setVisible(isEdit);
+        }
+
+        if (!isEdit) currentEditedRowIndex = -1;
+    }
+
+    private void toggleRoleName(int rowIndex, boolean isEdit) {
+        Node roleNameNode = getNodeByRowColumnIndex(rowIndex, 0);
+        String roleName = customRoles.get(getRoleIndexByRowIndex(currentEditedRowIndex)).getName();
+        if (roleNameNode instanceof Label roleNameLabel && isEdit) {
+            customRolesPane.getChildren().remove(roleNameLabel);
+            customRolesPane.add(new TextField(roleName), 0, rowIndex);
+        } else if (roleNameNode instanceof TextField roleNameField && !isEdit) {
+            customRolesPane.getChildren().remove(roleNameField);
+            Label roleNameLabel = new Label(roleName);
+            roleNameLabel.getStyleClass().add("parent-row");
+            customRolesPane.add(roleNameLabel, 0, rowIndex);
         }
     }
 
@@ -246,30 +388,104 @@ private void toggleRowEdit(int rowIndex, boolean isEdit) {
                         checkBox.setMouseTransparent(!isEdit);
                         checkBox.setFocusTraversable(isEdit);
                     }
-                    if (node instanceof Button button) {
-                        button.setVisible(isEdit); // Show save button
-                    }
                 });
     }
 
-    private void addSaveButton(CustomRole customRole, int rowIndex) {
-        Button saveButton = new Button();
-        saveButton.setGraphic(createImageView(saveImage));
-        saveButton.getStyleClass().add("standard-write-button");
+    private void toggleEditCancelButton(Button button, int rowIndex, boolean isEdit) {
+        System.out.println("Toggling edit button for row " + rowIndex);
+        button.getStyleClass().clear();
+
+        if (isEdit) {
+            styleCancelButton(button);
+            button.setOnAction(event -> {
+                toggleEditingRow(rowIndex, false);
+                refreshCheckboxSelections(rowIndex);
+            });
+        } else {
+            styleEditButton(button);
+            button.setOnAction(event -> toggleEditingRow(rowIndex, true));
+        }
+    }
+
+    private void refreshCheckboxSelections(int rowIndex) {
+        // Reselect based on the original permissions
+        int startingFeatureIndex = rowIndex + 1;
+        Permissions permissions = customRoles.get(getRoleIndexByRowIndex(rowIndex)).getPermissions();
+
+        // Row checkboxes
+        for (int col = 1; col <= operations.length; col++) {
+            Node node = getNodeByRowColumnIndex(rowIndex, col);
+            if (!(node instanceof CheckBox checkBox)) {
+                continue;
+            }
+            checkBox.setSelected(aggregatePermissionsByIndex(permissions, col - 1));
+        }
+
+        // Feature checkboxes
+        for (int i = 0; i < features.length; i++) {
+            int currentRowIndex = startingFeatureIndex + i;
+            FeaturePermissions featurePermissions = getFeaturePermissionsByFeatureName(permissions, features[i]);
 
-        saveButton.setOnAction(event -> saveRoleChanges(customRole, rowIndex));
+            for (int col = 1; col <= operations.length; col++) {
+                Node node = getNodeByRowColumnIndex(currentRowIndex, col);
 
+                if (!(node instanceof CheckBox checkBox)) {
+                    continue;
+                }
+
+                boolean hasPermission = getPermissionByColumnIndex(featurePermissions, col - 1);
+                checkBox.setSelected(hasPermission);
+            }
+        }
+    }
+
+    // - Save
+    private void addSaveButton(int rowIndex) {
+        Button saveButton = new Button();
+        styleSaveButton(saveButton);
         saveButton.setVisible(false); // Start hidden since edit is false
+
+        saveButton.setOnAction(event -> {
+            if (currentEditedRowIndex == -1) return;
+            CustomRole role = customRoles.get(getRoleIndexByRowIndex(currentEditedRowIndex));
+            openConfirmUpdateDialog(role);
+        });
+
         customRolesPane.add(saveButton, operations.length + 3, rowIndex);
     }
 
+    @Override
+    public void onConfirmCustomRoleUpdate(CustomRole customRole) {
+        if (currentEditedRowIndex != -1) {
+            saveRoleChanges(customRole, currentEditedRowIndex);
+        } else {
+            fallbackManager.setErrorMessage("No changes have been detected.");
+            closeConfirmUpdateDialog();
+        }
+    }
+
+    @Override
+    public void onCancelCustomRoleUpdate() {
+        closeConfirmUpdateDialog();
+    }
+
     private void saveRoleChanges(CustomRole customRole, int rowIndex) {
-        UpdateCustomRoleDTO updateCustomRoleDTO = gatherRolePermissions(customRole, rowIndex);
+        UpdateCustomRoleDTO updateCustomRoleDTO = gatherUpdatedCustomRole(customRole, rowIndex);
         System.out.println(updateCustomRoleDTO);
+
+        // Save changes
+        fallbackManager.setLoading(true);
+
+        customRoleService.updateCustomRole(updateCustomRoleDTO)
+                .thenAccept(updatedRole -> handleSuccessfulUpdate(updatedRole, rowIndex));
     }
 
-    private UpdateCustomRoleDTO gatherRolePermissions(CustomRole customRole, int startingRowIndex) {
-        // Initialize a new Permissions object to hold the aggregated permissions.
+    private UpdateCustomRoleDTO gatherUpdatedCustomRole(CustomRole customRole, int startingRowIndex) {
+        // Get updated role name
+        Node roleNameNode = getNodeByRowColumnIndex(startingRowIndex, 0);
+        String roleName = roleNameNode instanceof TextField textField ? textField.getText() : customRole.getName();
+
+        // Gather permissions
         Permissions permissions = new Permissions();
 
         int startingFeatureIndex = startingRowIndex + 1;
@@ -280,7 +496,7 @@ private UpdateCustomRoleDTO gatherRolePermissions(CustomRole customRole, int sta
             FeaturePermissions featurePermissions = new FeaturePermissions();
 
             for (int col = 1; col <= operations.length; col++) {
-                Node node = getNodeByRowColumnIndex(currentRowIndex, col, customRolesPane);
+                Node node = getNodeByRowColumnIndex(currentRowIndex, col);
 
                 if (!(node instanceof CheckBox checkBox)) {
                     continue;
@@ -288,36 +504,185 @@ private UpdateCustomRoleDTO gatherRolePermissions(CustomRole customRole, int sta
                 boolean isSelected = checkBox.isSelected();
 
                 // Assign permissions based on the column (operation)
-                switch (col) {
-                    case 1 -> featurePermissions.setCanRead(isSelected);
-                    case 2 -> featurePermissions.setCanCreate(isSelected);
-                    case 3 -> featurePermissions.setCanUpdate(isSelected);
-                    case 4 -> featurePermissions.setCanDelete(isSelected);
-                    default -> { break; }
-                }
+                setPermissionsByIndex(featurePermissions, col - 1, isSelected);
             }
 
             setFeaturePermissionsByFeatureName(permissions, features[i], featurePermissions);
         }
 
-        return new UpdateCustomRoleDTO(customRole.getId(), customRole.getName(), permissions);
+        return new UpdateCustomRoleDTO(customRole.getId(), roleName, permissions);
+    }
+
+    private void handleSuccessfulUpdate(Optional<CustomRole> updatedRoleOptional, int rowIndex) {
+        Platform.runLater(() -> {
+            if (updatedRoleOptional.isEmpty()) {
+                fallbackManager.setErrorMessage("Failed to update custom role.");
+                return;
+            }
+            CustomRole updatedRole = updatedRoleOptional.get();
+            closeConfirmUpdateDialog();
+
+            // Update customRoles
+            customRoles.set(getRoleIndexByRowIndex(rowIndex), updatedRole);
+
+            // Update UI
+            refreshCheckboxSelections(rowIndex);
+
+            // Disable editing row
+            toggleEditingRow(rowIndex, false);
+
+            // Hide save button
+            Node node = getNodeByRowColumnIndex(rowIndex, operations.length + 3);
+            if (node instanceof Button saveButton) {
+                saveButton.setVisible(false);
+            }
+
+            fallbackManager.setLoading(false);
+        });
+    }
+
+    // Delete
+    private void toggleDeleteMode() {
+        isDeleteMode = !isDeleteMode;
+
+        for (int row = 1; row < customRoles.size() * (features.length + 1) + 1; row++) {
+            Node node = getNodeByRowColumnIndex(row, operations.length + 4);
+            if (node instanceof Button deleteButton) {
+                deleteButton.setVisible(isDeleteMode);
+            }
+        }
+    }
+
+    private void addDeleteButton(CustomRole role, int rowIndex) {
+        Button deleteButton = new Button();
+        styleDeleteRoleButton(deleteButton);
+        deleteButton.setOnAction(event -> {
+            currentToBeDeletedRowIndex = rowIndex;
+            openConfirmDeleteDialog(role.getId());
+        });
+        applyStandardMargin(deleteButton);
+        deleteButton.setVisible(false);
+
+        customRolesPane.add(deleteButton, operations.length + 4, rowIndex);
+    }
+
+    @Override
+    public void onConfirmCustomRoleDelete(Integer customRoleId) {
+        if (currentToBeDeletedRowIndex != -1) {
+            handleDeleteRole(customRoleId, currentToBeDeletedRowIndex);
+        } else {
+            fallbackManager.setErrorMessage("No changes have been detected.");
+            closeConfirmUpdateDialog();
+        }
+    }
+
+    @Override
+    public void onCancelCustomRoleDelete() {
+        closeConfirmDeleteDialog();
+    }
+
+    private void handleDeleteRole(Integer customRoleId, int rowIndex) {
+        fallbackManager.setLoading(true);
+
+        customRoleService.deleteCustomRole(customRoleId)
+                .thenAccept(deletedRoleIdOptional -> handleSuccessfulDelete(deletedRoleIdOptional, rowIndex));
+    }
+
+    private void handleSuccessfulDelete(Optional<Integer> deletedRoleIdOptional, int rowIndex) {
+        Platform.runLater(() -> {
+            if (deletedRoleIdOptional.isEmpty()) {
+                fallbackManager.setErrorMessage("Failed to delete custom role.");
+                return;
+            }
+            closeConfirmDeleteDialog();
+
+            // Update customRoles
+            customRoles.remove(getRoleIndexByRowIndex(rowIndex));
+
+            // Update UI
+            tabTitle.setText("Custom Roles (" + customRoles.size() + ")");
+
+            // Rerender whole grid pane - necessary here, at least for rows after the deleted one
+            customRolesPane.getChildren().clear();
+            renderGridPane();
+
+            fallbackManager.setLoading(false);
+            toggleDeleteMode();
+        });
+    }
+
+    // Create
+    private void handleAddNewRole() {
+        // Add new role
+        String newRoleName = "New Role";
+        Permissions newPermissions = new Permissions();
+        CreateCustomRoleDTO roleDTO = new CreateCustomRoleDTO(newRoleName, organization.getId(), newPermissions);
+        customRoleService.createCustomRole(roleDTO)
+                .thenApply(this::handleNewRoleResponse)
+                .exceptionally(ex -> {
+                    Platform.runLater(() -> fallbackManager.setErrorMessage("Failed to create new custom role."));
+                    return Optional.empty();
+                });
+    }
+
+    private Optional<CustomRole> handleNewRoleResponse(Optional<CustomRole> newRoleOptional) {
+        Platform.runLater(() -> {
+            if (newRoleOptional.isEmpty()) {
+                fallbackManager.setErrorMessage("Failed to create new custom role.");
+                return;
+            }
+            CustomRole newRole = newRoleOptional.get();
+            customRoles.add(newRole);
+            tabTitle.setText("Custom Roles (" + customRoles.size() + ")");
+
+            // Render new role row and feature rows
+            int newRowIndex = (customRoles.size() - 1) * (features.length + 1) + 1;
+            addRoleRow(newRole, newRowIndex++);
+
+            for (String feature : features) {
+                addFeaturePermissionRow(feature, newRole, newRowIndex++);
+            }
+        });
+        return newRoleOptional;
     }
 
     // Utils
+    private void openConfirmUpdateDialog(CustomRole customRole) {
+        confirmCustomRoleUpdateController.setData(customRole);
+        confirmUpdateDialogContainer.setVisible(true);
+        confirmUpdateDialogContainer.setManaged(true);
+    }
+
+    private void closeConfirmUpdateDialog() {
+        confirmUpdateDialogContainer.setVisible(false);
+        confirmUpdateDialogContainer.setManaged(false);
+    }
+
+    private void openConfirmDeleteDialog(Integer customRoleId) {
+        confirmCustomRoleDeleteController.setData(customRoleId);
+        confirmDeleteDialogContainer.setVisible(true);
+        confirmDeleteDialogContainer.setManaged(true);
+    }
+
+    private void closeConfirmDeleteDialog() {
+        confirmDeleteDialogContainer.setVisible(false);
+        confirmDeleteDialogContainer.setManaged(false);
+    }
+
     private boolean aggregatePermissionsByIndex(Permissions permissions, int index) {
-        return getPermissionByIndex(permissions.getProducts(), index) &&
-                getPermissionByIndex(permissions.getFactories(), index) &&
-                getPermissionByIndex(permissions.getWarehouses(), index) &&
-                getPermissionByIndex(permissions.getSuppliers(), index) &&
-                getPermissionByIndex(permissions.getClients(), index);
+        return getPermissionByColumnIndex(permissions.getProducts(), index) &&
+                getPermissionByColumnIndex(permissions.getFactories(), index) &&
+                getPermissionByColumnIndex(permissions.getWarehouses(), index) &&
+                getPermissionByColumnIndex(permissions.getSuppliers(), index) &&
+                getPermissionByColumnIndex(permissions.getClients(), index);
     }
 
-    private boolean getPermissionByIndex(FeaturePermissions featurePermissions, int index) {
+    private boolean getPermissionByColumnIndex(FeaturePermissions featurePermissions, int columnIndex) {
         if (featurePermissions == null) {
             return false;
         }
 
-        return switch (index) {
+        return switch (columnIndex) {
             case 0 -> Optional.ofNullable(featurePermissions.getCanRead()).orElse(false);
             case 1 -> Optional.ofNullable(featurePermissions.getCanCreate()).orElse(false);
             case 2 -> Optional.ofNullable(featurePermissions.getCanUpdate()).orElse(false);
@@ -326,6 +691,20 @@ private boolean getPermissionByIndex(FeaturePermissions featurePermissions, int
         };
     }
 
+    private int getRoleIndexByRowIndex(int rowIndex) {
+        return rowIndex / (features.length + 1);
+    }
+
+    private void setPermissionsByIndex(FeaturePermissions featurePermissions, int index, boolean value) {
+        switch (index) {
+            case 0 -> featurePermissions.setCanRead(value);
+            case 1 -> featurePermissions.setCanCreate(value);
+            case 2 -> featurePermissions.setCanUpdate(value);
+            case 3 -> featurePermissions.setCanDelete(value);
+            default -> { break; }
+        }
+    }
+
     private FeaturePermissions getFeaturePermissionsByFeatureName(Permissions permissions, String featureName) {
         return switch (featureName) {
             case "Products" -> permissions.getProducts();
@@ -348,9 +727,9 @@ private void setFeaturePermissionsByFeatureName(Permissions permissions, String
         }
     }
 
-    private Node getNodeByRowColumnIndex(final int row, final int column, GridPane gridPane) {
+    private Node getNodeByRowColumnIndex(final int row, final int column) {
         Node result = null;
-        for (Node node : gridPane.getChildren()) {
+        for (Node node : customRolesPane.getChildren()) {
             if(GridPane.getRowIndex(node) == row && GridPane.getColumnIndex(node) == column) {
                 result = node;
                 break;
@@ -359,6 +738,46 @@ private Node getNodeByRowColumnIndex(final int row, final int column, GridPane g
         return result;
     }
 
+    // Button styling
+    private void styleAddNewRoleButton(Button button) {
+        button.getStyleClass().add("standard-write-button");
+        button.setGraphic(createImageView(plusImage));
+        button.setText("Add New Role");
+        applyStandardMargin(button);
+    }
+
+    private void styleDeleteRoleButton(Button button) {
+        button.getStyleClass().add("standard-delete-button");
+        button.setGraphic(createImageView(trashImage));
+        button.setTooltip(new Tooltip("Delete Role"));
+        GridPane.setMargin(button, new Insets(12));
+    }
+
+    private void styleExpandButton(Button button) {
+        button.getStyleClass().add("no-style-button");
+        button.setGraphic(createImageView(angleDownImage));
+        button.setTooltip(new Tooltip("Expand"));
+        applyStandardMargin(button);
+    }
+
+    private void styleEditButton(Button button) {
+        button.getStyleClass().add("standard-write-button");
+        button.setGraphic(createImageView(editImage));
+        button.setTooltip(new Tooltip("Edit Role"));
+    }
+
+    private void styleSaveButton(Button button) {
+        button.getStyleClass().add("standard-write-button");
+        button.setGraphic(createImageView(saveImage));
+        button.setTooltip(new Tooltip("Save Changes"));
+        GridPane.setMargin(button, new Insets(12));
+    }
+
+    private void styleCancelButton(Button button) {
+        button.getStyleClass().add("cancel-edit-button");
+        button.setGraphic(createImageView(cancelImage));
+    }
+
     private ImageView createImageView(Image image) {
         ImageView imageView = new ImageView(image);
         imageView.setFitWidth(12);
@@ -367,6 +786,6 @@ private ImageView createImageView(Image image) {
     }
 
     private void applyStandardMargin(Node node) {
-        GridPane.setMargin(node, new Insets(10, 40, 10, 40));
+        GridPane.setMargin(node, new Insets(12, 36, 12, 36));
     }
 }
diff --git a/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationOverviewController.java b/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationOverviewController.java
index 6f949a1d..e2aab80d 100644
--- a/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationOverviewController.java
+++ b/src/main/java/org/chainoptim/desktop/core/organization/controller/OrganizationOverviewController.java
@@ -5,23 +5,47 @@
 import org.chainoptim.desktop.shared.util.DataReceiver;
 
 import javafx.fxml.FXML;
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.control.Button;
 import javafx.scene.control.Label;
+import javafx.scene.control.Tooltip;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.GridPane;
 import javafx.scene.layout.HBox;
-import javafx.scene.layout.VBox;
+
+import java.util.Objects;
 
 public class OrganizationOverviewController implements DataReceiver<Organization> {
 
+    // State
     private Organization organization;
+    private boolean isDeleteMode = false;
 
+    // FXML
+    @FXML
+    private Label tabTitle;
+    @FXML
+    private Button removeMemberButton;
+    @FXML
+    private Button addNewMemberButton;
     @FXML
-    private VBox usersVBox;
+    private GridPane membersGridPane;
+
+    // Constants
+    String[] headers = {"Username", "Role", "Custom Role"};
+
+    // Icons
+    private Image plusImage;
+    private Image trashImage;
 
     @Override
     public void setData(Organization data) {
         this.organization = data;
 
         initializeUI();
-
     }
 
     private void initializeUI() {
@@ -29,20 +53,86 @@ private void initializeUI() {
             return;
         }
 
+        initializeIcons();
+
+        // Initialize title container
+        tabTitle.setText("Members (" + organization.getUsers().size() + ")");
+        styleDeleteRoleButton(removeMemberButton);
+        removeMemberButton.setOnAction(event -> toggleDeleteMode());
+        styleAddNewRoleButton(addNewMemberButton);
+        addNewMemberButton.setOnAction(event -> {});
+
+        // Render members grid
+        renderMembersGrid();
+    }
+
+    private void initializeIcons() {
+        plusImage = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/img/plus.png")));
+        trashImage = new Image(Objects.requireNonNull(getClass().getResourceAsStream("/img/trash-solid.png")));
+    }
+
+    private void renderMembersGrid() {
+        membersGridPane.getChildren().clear();
+
+        // Headers
+        for (int i = 0; i < headers.length; i++) {
+            Label label = new Label(headers[i]);
+            label.getStyleClass().add("column-header");
+            membersGridPane.add(label, i, 0);
+            GridPane.setHalignment(label, HPos.CENTER);
+        }
+
+        // Rows
+        int row = 1;
         for (User user : organization.getUsers()) {
-            HBox rowHbox = new HBox();
-            rowHbox.setSpacing(120);
-            Label usernameLabel = new Label(user.getUsername());
-            rowHbox.getChildren().add(usernameLabel);
-            Label roleLabel = new Label(user.getRole().toString());
-            rowHbox.getChildren().add(roleLabel);
-            if (user.getCustomRole() != null) {
-                Label customRoleLabel = new Label(user.getCustomRole().getName());
-                rowHbox.getChildren().add(customRoleLabel);
-            } else {
-                rowHbox.getChildren().add(new Label("Not assigned"));
+            for (int i = 0; i < headers.length; i++) {
+                String property = getDisplayedPropertyByHeader(user, headers[i]);
+                Label label = new Label(property);
+                applyStandardMargin(label);
+                membersGridPane.add(label, i, row);
+                GridPane.setHalignment(label, HPos.CENTER);
             }
-            usersVBox.getChildren().add(rowHbox);
+            row++;
         }
     }
+
+    private String getDisplayedPropertyByHeader(User user, String header) {
+        return switch (header) {
+            case "Username" -> user.getUsername();
+            case "Role" -> user.getRole().toString();
+            case "Custom Role" -> user.getCustomRole() != null ? user.getCustomRole().getName() : "Not assigned";
+            default -> null;
+        };
+    }
+
+    private void toggleDeleteMode() {
+        isDeleteMode = !isDeleteMode;
+    }
+
+
+    // TODO: Take this into separate class and reuse
+    private void styleAddNewRoleButton(Button button) {
+        button.getStyleClass().add("standard-write-button");
+        button.setGraphic(createImageView(plusImage));
+        button.setText("Add New Member");
+        applyStandardMargin(button);
+    }
+
+    private void styleDeleteRoleButton(Button button) {
+        button.getStyleClass().add("standard-delete-button");
+        button.setGraphic(createImageView(trashImage));
+        button.setTooltip(new Tooltip("Delete Member"));
+        GridPane.setMargin(button, new Insets(12));
+    }
+
+    private ImageView createImageView(Image image) {
+        ImageView imageView = new ImageView(image);
+        imageView.setFitWidth(12);
+        imageView.setFitHeight(12);
+        return imageView;
+    }
+
+    private void applyStandardMargin(Node node) {
+        GridPane.setMargin(node, new Insets(12, 36, 12, 36));
+    }
 }
diff --git a/src/main/java/org/chainoptim/desktop/core/organization/model/ConfirmDeleteDialogActionListener.java b/src/main/java/org/chainoptim/desktop/core/organization/model/ConfirmDeleteDialogActionListener.java
new file mode 100644
index 00000000..ed536277
--- /dev/null
+++ b/src/main/java/org/chainoptim/desktop/core/organization/model/ConfirmDeleteDialogActionListener.java
@@ -0,0 +1,7 @@
+package org.chainoptim.desktop.core.organization.model;
+
+public interface ConfirmDeleteDialogActionListener {
+
+    void onConfirmCustomRoleDelete(Integer customRoleId);
+    void onCancelCustomRoleDelete();
+}
diff --git a/src/main/java/org/chainoptim/desktop/core/organization/model/ConfirmUpdateDialogActionListener.java b/src/main/java/org/chainoptim/desktop/core/organization/model/ConfirmUpdateDialogActionListener.java
new file mode 100644
index 00000000..01a98e69
--- /dev/null
+++ b/src/main/java/org/chainoptim/desktop/core/organization/model/ConfirmUpdateDialogActionListener.java
@@ -0,0 +1,7 @@
+package org.chainoptim.desktop.core.organization.model;
+
+public interface ConfirmUpdateDialogActionListener {
+
+    void onConfirmCustomRoleUpdate(CustomRole customRole);
+    void onCancelCustomRoleUpdate();
+}
diff --git a/src/main/java/org/chainoptim/desktop/core/user/service/UserService.java b/src/main/java/org/chainoptim/desktop/core/user/service/UserService.java
index aad71b4b..61a989c8 100644
--- a/src/main/java/org/chainoptim/desktop/core/user/service/UserService.java
+++ b/src/main/java/org/chainoptim/desktop/core/user/service/UserService.java
@@ -2,10 +2,11 @@
 
 import org.chainoptim.desktop.core.user.model.User;
 
-import java.io.UnsupportedEncodingException;
+import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
 public interface UserService {
-    CompletableFuture<Optional<User>> getUserByUsername(String username) throws UnsupportedEncodingException;
+    CompletableFuture<Optional<User>> getUserByUsername(String username);
+    CompletableFuture<Optional<List<User>>> getUsersByCustomRoleId(Integer customRoleId);
 }
diff --git a/src/main/java/org/chainoptim/desktop/core/user/service/UserServiceImpl.java b/src/main/java/org/chainoptim/desktop/core/user/service/UserServiceImpl.java
index 57bf91a7..d9cbf8a8 100644
--- a/src/main/java/org/chainoptim/desktop/core/user/service/UserServiceImpl.java
+++ b/src/main/java/org/chainoptim/desktop/core/user/service/UserServiceImpl.java
@@ -4,6 +4,8 @@
 import org.chainoptim.desktop.shared.util.JsonUtil;
 import org.chainoptim.desktop.core.user.util.TokenManager;
 
+import com.fasterxml.jackson.core.type.TypeReference;
+
 import java.io.UnsupportedEncodingException;
 import java.net.HttpURLConnection;
 import java.net.URI;
@@ -12,6 +14,7 @@
 import java.net.http.HttpRequest;
 import java.net.http.HttpResponse;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
@@ -19,17 +22,20 @@ public class UserServiceImpl implements UserService {
 
     private final HttpClient client = HttpClient.newHttpClient();
 
-    public CompletableFuture<Optional<User>> getUserByUsername(String username) throws UnsupportedEncodingException {
+    private static final String HEADER_KEY = "Authorization";
+    private static final String HEADER_VALUE_PREFIX = "Bearer ";
+
+    public CompletableFuture<Optional<User>> getUserByUsername(String username) {
         String encodedUsername = URLEncoder.encode(username, StandardCharsets.UTF_8);
         String routeAddress = "http://localhost:8080/api/v1/users/username/" + encodedUsername;
 
-        // Retrieve the saved JWT token
         String jwtToken = TokenManager.getToken();
+        if (jwtToken == null) return new CompletableFuture<>();
+        String headerValue = HEADER_VALUE_PREFIX + jwtToken;
 
         HttpRequest request = HttpRequest.newBuilder()
                 .uri(URI.create(routeAddress))
-                // Include the JWT in the Authorization header
-                .header("Authorization", "Bearer " + jwtToken)
+                .headers(HEADER_KEY, headerValue)
                 .GET()
                 .build();
 
@@ -46,5 +52,34 @@ public CompletableFuture<Optional<User>> getUserByUsername(String username) thro
                     return Optional.empty();
                 });
     }
+
+    public CompletableFuture<Optional<List<User>>> getUsersByCustomRoleId(Integer customRoleId) {
+        String routeAddress = "http://localhost:8080/api/v1/users/search/custom-role/" + customRoleId;
+
+        String jwtToken = TokenManager.getToken();
+        if (jwtToken == null) return new CompletableFuture<>();
+        String headerValue = HEADER_VALUE_PREFIX + jwtToken;
+
+        HttpRequest request = HttpRequest.newBuilder()
+                .uri(URI.create(routeAddress))
+                .headers(HEADER_KEY, headerValue)
+                .GET()
+                .build();
+
+        return client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
+                .thenApply(response -> {
+                    if (response.statusCode() != HttpURLConnection.HTTP_OK)
+                        return Optional.<List<User>>empty();
+
+                    try {
+                        List<User> users = JsonUtil.getObjectMapper().readValue(response.body(), new TypeReference<List<User>>() {});
+                        return Optional.of(users);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+
+                    return Optional.<List<User>>empty();
+                });
+    }
 }
 
diff --git a/src/main/java/org/chainoptim/desktop/shared/fallback/FallbackManager.java b/src/main/java/org/chainoptim/desktop/shared/fallback/FallbackManager.java
index f65124b5..824923df 100644
--- a/src/main/java/org/chainoptim/desktop/shared/fallback/FallbackManager.java
+++ b/src/main/java/org/chainoptim/desktop/shared/fallback/FallbackManager.java
@@ -67,10 +67,12 @@ public BooleanProperty noResultsProperty() {
     }
 
     public void reset() {
-        setErrorMessage("");
-        setLoading(false);
-        setNoOrganization(false);
-        setNoResults(false);
+        if (!isEmpty.get()) {
+            setErrorMessage("");
+            setLoading(false);
+            setNoOrganization(false);
+            setNoResults(false);
+        }
     }
 
     public BooleanProperty isEmptyProperty() {
diff --git a/src/main/java/org/chainoptim/desktop/shared/fallback/FallbackManagerController.java b/src/main/java/org/chainoptim/desktop/shared/fallback/FallbackManagerController.java
index 037b85aa..28233609 100644
--- a/src/main/java/org/chainoptim/desktop/shared/fallback/FallbackManagerController.java
+++ b/src/main/java/org/chainoptim/desktop/shared/fallback/FallbackManagerController.java
@@ -29,33 +29,10 @@ public FallbackManagerController(FallbackManager fallbackManager) {
 
     @FXML
     public void initialize() {
-        loadFallbackViews();
         setupChangeListeners();
         updateView();
     }
 
-    private void loadFallbackViews() {
-        String[] viewPaths = {
-                "/org/chainoptim/desktop/shared/fallback/ErrorFallbackView.fxml",
-                "/org/chainoptim/desktop/shared/fallback/LoadingFallbackView.fxml",
-                "/org/chainoptim/desktop/shared/fallback/NoOrganizationFallbackView.fxml",
-                "/org/chainoptim/desktop/shared/fallback/NoResultsFallbackView.fxml"
-        };
-
-        for (String path : viewPaths) {
-            try {
-                FXMLLoader loader = new FXMLLoader(getClass().getResource(path));
-                Node view = loader.load();
-                Object controller = loader.getController();
-
-                loadedViews.put(path, view);
-                loadedControllers.put(path, controller);
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
     private void setupChangeListeners() {
         fallbackManager.errorMessageProperty().addListener((obs, oldVal, newVal) -> updateView());
         fallbackManager.isLoadingProperty().addListener((obs, oldVal, newVal) -> updateView());
@@ -66,19 +43,25 @@ private void setupChangeListeners() {
     private void updateView() {
         String viewPath = determineViewPathBasedOnState();
 
-        if (!viewPath.isEmpty()) {
-            Node view = loadedViews.get(viewPath);
-            // Set error message in case of error
-            Object controller = loadedControllers.get(viewPath);
-            if (viewPath.equals("/org/chainoptim/desktop/shared/fallback/ErrorFallbackView.fxml")) {
-                ((ErrorFallbackController)controller).initialize(fallbackManager.getErrorMessage());
-            }
-
-            fallbackContentHolder.getChildren().setAll(view);
-        } else {
+        if (viewPath.isEmpty()) { // No fallback
             fallbackContentHolder.getChildren().clear();
             fallbackContentHolder.setPrefSize(0, 0);
+            return;
         }
+
+        // Look in cache or load
+        if (!loadedViews.containsKey(viewPath)) {
+            loadFallbackView(viewPath);
+        }
+        Node view = loadedViews.get(viewPath);
+
+        // Set error message in case of error
+        Object controller = loadedControllers.get(viewPath);
+        if (viewPath.equals("/org/chainoptim/desktop/shared/fallback/ErrorFallbackView.fxml")) {
+            ((ErrorFallbackController)controller).initialize(fallbackManager.getErrorMessage());
+        }
+
+        fallbackContentHolder.getChildren().setAll(view);
     }
 
     private String determineViewPathBasedOnState() {
@@ -94,4 +77,17 @@ private String determineViewPathBasedOnState() {
         return "";
     }
 
+    private void loadFallbackView(String viewPath) {
+        try {
+            FXMLLoader loader = new FXMLLoader(getClass().getResource(viewPath));
+            Node view = loader.load();
+            Object controller = loader.getController();
+
+            loadedViews.put(viewPath, view);
+            loadedControllers.put(viewPath, controller);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/resources/css/buttons.css b/src/main/resources/css/buttons.css
index 84a48037..a2281601 100644
--- a/src/main/resources/css/buttons.css
+++ b/src/main/resources/css/buttons.css
@@ -13,6 +13,22 @@
     -fx-background-color: #0068C9;
 }
 
+.standard-delete-button {
+    -fx-pref-height: 32px;
+    /* Find more professional red*/
+    -fx-background-color: #B22222;
+    -fx-text-fill: white;
+    -fx-font-weight: normal;
+    -fx-font-size: 14px;
+    -fx-padding: 4px 12px 4px 12px;
+    -fx-graphic-text-gap: 8px;
+    -fx-cursor: hand;
+}
+
+.standard-delete-button:hover {
+    -fx-background-color: #A52A2A;
+}
+
 /* Button with default JavaFX styles removed */
 .no-style-button {
     -fx-background-color: transparent;
diff --git a/src/main/resources/css/dialogs.css b/src/main/resources/css/dialogs.css
new file mode 100644
index 00000000..3289d4c3
--- /dev/null
+++ b/src/main/resources/css/dialogs.css
@@ -0,0 +1,41 @@
+
+.generic-dialog {
+    -fx-background-color: #f3f3f3;
+    -fx-padding: 20px;
+    -fx-border-color: #d3d3d3;
+    -fx-border-radius: 6px;
+    -fx-border-width: 1px;
+    -fx-shadow-highlight-color: #d3d3d3;
+}
+
+.dialog-title {
+    -fx-font-size: 18px;
+    -fx-font-weight: bold;
+}
+
+.dialog-message {
+    -fx-padding: 8px 0px;
+    -fx-font-size: 14px;
+    -fx-font-weight: normal;
+}
+
+.dialog-confirm-button {
+    -fx-pref-height: 32px;
+    -fx-background-color: #006AEE;
+    -fx-text-fill: white;
+    -fx-font-weight: normal;
+    -fx-font-size: 14px;
+    -fx-padding: 4px 12px 4px 12px;
+    -fx-graphic-text-gap: 8px;
+    -fx-cursor: hand;
+}
+
+.dialog-cancel-button {
+    -fx-pref-height: 32px;
+    -fx-padding: 4px 12px 4px 12px;
+    -fx-background-color: #ffffff;
+    -fx-border-color: #d3d3d3;
+    -fx-border-radius: 6px;
+    -fx-graphic-text-gap: 8px;
+    -fx-cursor: hand;
+}
\ No newline at end of file
diff --git a/src/main/resources/css/globals.css b/src/main/resources/css/globals.css
index 75551d75..7297f3f0 100644
--- a/src/main/resources/css/globals.css
+++ b/src/main/resources/css/globals.css
@@ -8,4 +8,5 @@
 @import url("table.css");
 @import url("factory-production.css");
 @import url("fallback.css");
-@import url("organization.css");
\ No newline at end of file
+@import url("organization.css");
+@import url("dialogs.css");
\ No newline at end of file
diff --git a/src/main/resources/css/organization.css b/src/main/resources/css/organization.css
index 1292dda4..dfa43b8a 100644
--- a/src/main/resources/css/organization.css
+++ b/src/main/resources/css/organization.css
@@ -15,10 +15,24 @@
     -fx-font-weight: bold;
 }
 
+.tab-title-container {
+    -fx-padding: 20px;
+    -fx-border-color: transparent transparent #dcdcdc transparent;
+    -fx-border-width: 0 0 1 0;
+}
+
+.tab-title {
+    -fx-font-size: 18px;
+    -fx-font-weight: bold;
+}
+
 /* Custom Roles */
 .column-header {
+    -fx-padding: 8px 0px;
     -fx-font-size: 16px;
     -fx-font-weight: bold;
+    -fx-border-color: transparent transparent #dcdcdc transparent;
+    -fx-border-width: 0 0 1 0;
 }
 
 .parent-row {
@@ -32,4 +46,19 @@ scroll-pane {
 
 .scroll-pane .viewport {
     -fx-background-color: white;
+}
+
+.custom-checkbox {
+    -fx-cursor: hand;
+}
+
+.cancel-edit-button {
+    -fx-pref-height: 32px;
+    -fx-padding: 8px 10px;
+    -fx-background-color: #e6e6e6;
+    -fx-border-color: #d3d3d3;
+    -fx-background-radius: 6px;
+    -fx-border-radius: 6px;
+    -fx-graphic-text-gap: 8px;
+    -fx-cursor: hand;
 }
\ No newline at end of file
diff --git a/src/main/resources/img/xmark-solid.png b/src/main/resources/img/xmark-solid.png
new file mode 100644
index 00000000..bfeb59b5
Binary files /dev/null and b/src/main/resources/img/xmark-solid.png differ
diff --git a/src/main/resources/org/chainoptim/desktop/core/organization/ConfirmCustomRoleDeleteView.fxml b/src/main/resources/org/chainoptim/desktop/core/organization/ConfirmCustomRoleDeleteView.fxml
new file mode 100644
index 00000000..2398a547
--- /dev/null
+++ b/src/main/resources/org/chainoptim/desktop/core/organization/ConfirmCustomRoleDeleteView.fxml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?import javafx.scene.layout.*?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.ScrollPane?>
+<?import javafx.scene.text.Text?>
+<?import javafx.scene.text.TextFlow?>
+
+<VBox xmlns="http://javafx.com/javafx"
+      xmlns:fx="http://javafx.com/fxml"
+      fx:controller="org.chainoptim.desktop.core.organization.controller.ConfirmCustomRoleDeleteController"
+      prefHeight="400.0" prefWidth="400.0" styleClass="generic-dialog">
+
+    <Label text="Confirm Custom Role Delete" styleClass="dialog-title"/>
+
+    <VBox spacing="8">
+        <TextFlow styleClass="dialog-message" VBox.vgrow="ALWAYS">
+            <Text text="Are you sure you want to delete this custom role? The following members will be affected by this change: " />
+        </TextFlow>
+
+        <ScrollPane VBox.vgrow="ALWAYS" fitToWidth="true">
+            <VBox fx:id="usersVBox" spacing="8" style="-fx-padding: 10; -fx-font-size: 14px; -fx-font-weight: bold;"/>
+        </ScrollPane>
+    </VBox>
+
+    <Pane VBox.vgrow="ALWAYS" />
+
+    <HBox alignment="CENTER" spacing="10" style="-fx-padding: 10px 0px 0px 0px;">
+        <Button text="Cancel" fx:id="cancelButton" onAction="#onCancelButtonClicked" styleClass="dialog-cancel-button" HBox.hgrow="ALWAYS"/>
+        <Region HBox.hgrow="ALWAYS" />
+        <Button text="Confirm" fx:id="confirmButton" onAction="#onConfirmButtonClicked" styleClass="dialog-confirm-button" HBox.hgrow="ALWAYS"/>
+    </HBox>
+</VBox>
diff --git a/src/main/resources/org/chainoptim/desktop/core/organization/ConfirmCustomRoleUpdateView.fxml b/src/main/resources/org/chainoptim/desktop/core/organization/ConfirmCustomRoleUpdateView.fxml
new file mode 100644
index 00000000..8a3d778c
--- /dev/null
+++ b/src/main/resources/org/chainoptim/desktop/core/organization/ConfirmCustomRoleUpdateView.fxml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?import javafx.scene.layout.*?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.ScrollPane?>
+<?import javafx.scene.text.Text?>
+<?import javafx.scene.text.TextFlow?>
+
+<VBox xmlns="http://javafx.com/javafx"
+      xmlns:fx="http://javafx.com/fxml"
+      fx:controller="org.chainoptim.desktop.core.organization.controller.ConfirmCustomRoleUpdateController"
+      prefHeight="400.0" prefWidth="400.0" styleClass="generic-dialog">
+
+    <Label text="Confirm Custom Role Update" styleClass="dialog-title"/>
+
+    <VBox spacing="8">
+        <TextFlow styleClass="dialog-message" VBox.vgrow="ALWAYS">
+            <Text text="Are you sure you want to update this custom role? The following members will be affected by this change: " />
+        </TextFlow>
+
+        <ScrollPane VBox.vgrow="ALWAYS" fitToWidth="true">
+            <VBox fx:id="usersVBox" spacing="8" style="-fx-padding: 10; -fx-font-size: 14px; -fx-font-weight: bold;"/>
+        </ScrollPane>
+    </VBox>
+
+    <Pane VBox.vgrow="ALWAYS" />
+
+    <HBox alignment="CENTER" spacing="10" style="-fx-padding: 10px 0px 0px 0px;">
+        <Button text="Cancel" fx:id="cancelButton" onAction="#onCancelButtonClicked" styleClass="dialog-cancel-button" HBox.hgrow="ALWAYS"/>
+        <Region HBox.hgrow="ALWAYS" />
+        <Button text="Confirm" fx:id="confirmButton" onAction="#onConfirmButtonClicked" styleClass="dialog-confirm-button" HBox.hgrow="ALWAYS"/>
+    </HBox>
+</VBox>
diff --git a/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationCustomRolesView.fxml b/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationCustomRolesView.fxml
index f28aa27d..b22c0542 100644
--- a/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationCustomRolesView.fxml
+++ b/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationCustomRolesView.fxml
@@ -1,14 +1,28 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?import javafx.scene.layout.*?>
-
 <?import javafx.scene.control.ScrollPane?>
-<VBox xmlns="http://javafx.com/javafx"
-      xmlns:fx="http://javafx.com/fxml"
-      fx:controller="org.chainoptim.desktop.core.organization.controller.OrganizationCustomRolesController"
-      styleClass="organization-content-container"
-      prefHeight="600" prefWidth="800">
-
-    <ScrollPane VBox.vgrow="ALWAYS" style="-fx-background-color: white">
-        <GridPane fx:id="customRolesPane" VBox.vgrow="ALWAYS" style="-fx-background-color: white"/>
-    </ScrollPane>
-</VBox>
+<?import javafx.scene.control.Button?>
+
+<?import javafx.scene.control.Label?>
+<StackPane xmlns="http://javafx.com/javafx"
+           xmlns:fx="http://javafx.com/fxml"
+           fx:controller="org.chainoptim.desktop.core.organization.controller.OrganizationCustomRolesController"
+            prefHeight="800">
+
+    <VBox spacing="10">
+        <HBox styleClass="tab-title-container" spacing="10">
+            <Label fx:id="tabTitle" styleClass="tab-title"/>
+            <Region HBox.hgrow="ALWAYS"/>
+            <Button fx:id="deleteRoleButton"/>
+            <Button fx:id="addNewRoleButton"/>
+        </HBox>
+
+        <ScrollPane VBox.vgrow="ALWAYS" style="-fx-background-color: white">
+            <GridPane fx:id="customRolesPane" VBox.vgrow="ALWAYS"
+                      style="-fx-background-color: white; -fx-padding: 0px 20px;"/>
+        </ScrollPane>
+    </VBox>
+
+    <StackPane fx:id="confirmUpdateDialogContainer" style="-fx-padding: 64px"/>
+    <StackPane fx:id="confirmDeleteDialogContainer" style="-fx-padding: 64px"/>
+</StackPane>
diff --git a/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationOverviewView.fxml b/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationOverviewView.fxml
index b2aea823..2d575bda 100644
--- a/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationOverviewView.fxml
+++ b/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationOverviewView.fxml
@@ -1,17 +1,26 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<?import javafx.scene.control.*?>
 <?import javafx.scene.layout.*?>
 
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.ScrollPane?>
 <VBox xmlns="http://javafx.com/javafx"
-            xmlns:fx="http://javafx.com/fxml"
-            fx:controller="org.chainoptim.desktop.core.organization.controller.OrganizationOverviewController"
-            styleClass="organization-content-container">
+      xmlns:fx="http://javafx.com/fxml"
+      fx:controller="org.chainoptim.desktop.core.organization.controller.OrganizationOverviewController"
+        prefHeight="800">
 
-    <HBox spacing="120">
-        <Label text="Members" styleClass="organization-common-label"/>
-        <Label text="Base Role" styleClass="organization-common-label"/>
-        <Label text="Custom Role" styleClass="organization-common-label"/>
-    </HBox>
+    <VBox spacing="10">
+        <HBox styleClass="tab-title-container" spacing="10">
+            <Label fx:id="tabTitle" styleClass="tab-title"/>
+            <Region HBox.hgrow="ALWAYS"/>
+            <Button fx:id="removeMemberButton"/>
+            <Button fx:id="addNewMemberButton"/>
+        </HBox>
+
+        <ScrollPane VBox.vgrow="ALWAYS" style="-fx-background-color: white">
+            <GridPane fx:id="membersGridPane" VBox.vgrow="ALWAYS"
+                      style="-fx-background-color: white; -fx-padding: 0px 20px;"/>
+        </ScrollPane>
+    </VBox>
 
-    <VBox fx:id="usersVBox" spacing="20"/>
 </VBox>
diff --git a/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationView.fxml b/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationView.fxml
index 13effcd5..82a0691e 100644
--- a/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationView.fxml
+++ b/src/main/resources/org/chainoptim/desktop/core/organization/OrganizationView.fxml
@@ -15,7 +15,7 @@
             </VBox>
             <VBox HBox.hgrow="ALWAYS" alignment="TOP_RIGHT" spacing="10">
                 <Label fx:id="planLabel" styleClass="plan-label"/>
-                <Button text="Change Plan" onAction="#handleChangePlan" styleClass="standard-write-button"/>
+                <Button text="Edit Organization" onAction="#handleEditOrganization" styleClass="standard-write-button"/>
             </VBox>
         </HBox>
     </VBox>