diff --git a/README.md b/README.md
index a186038..4e2f021 100644
--- a/README.md
+++ b/README.md
@@ -732,7 +732,7 @@ Alternatively, you can use Docker for the server by pulling plexpass image as fo
 docker pull plexobject/plexpass:latest
 docker run -p 8080:8080 -p 8443:8443 -e DEVICE_PEPPER_KEY=$DEVICE_PEPPER_KEY 
 	-e DATA_DIR=/data -e CERT_FILE=/data/cert-pass.pem 
-    -e KEY_FILE=/data/key-pass.pem -v $PARENT_DIR/PlexPassData:/data plexpass server
+    -e KEY_FILE=/data/key-pass.pem -v $PARENT_DIR/PlexPassData:/data plexobject/plexpass server
 ```
 
 Note: You only need to run server when using REST APIs or a UI for the web application.
diff --git a/assets/javascript/plexpass.js b/assets/javascript/plexpass.js
index f202c6f..80a19c0 100644
--- a/assets/javascript/plexpass.js
+++ b/assets/javascript/plexpass.js
@@ -161,12 +161,12 @@ async function viewAccount(id) {
             stopFetchingOTP();
         });
     }
-    if (account.kind === 'Login') {
-        expandAccordionSection('collapseLoginInfo');
-    } else if (account.kind === 'Contact') {
+    if (account.kind === 'Contacts' || account.category === 'Contacts') {
         expandAccordionSection('collapseContactInfo');
-    } else if (account.kind === 'Notes' || account.kind === 'Custom') {
+    } else if (account.kind === 'Notes' || account.kind === 'Custom' || account.category === 'Notes' || account.category === 'Custom') {
         expandAccordionSection('collapseNotesInfo');
+    } else if (account.kind === 'Logins' || account.category === 'Logins') {
+        expandAccordionSection('collapseLoginInfo');
     }
     await viewModal.show();
 }
@@ -464,18 +464,19 @@ async function showAccountForm(account) {
     }
 
     const accountKind = document.getElementById('accountKind').value;
-    if (accountKind === 'Login') {
-        const loginCollapse = new bootstrap.Collapse(document.getElementById('collapseLogin'), {
-            toggle: true
-        });
-    } else if (accountKind === 'Contact') {
+    const editCategory = document.getElementById('editCategory').value;
+    if (accountKind === 'Contacts' || editCategory === 'Contacts') {
         const contactCollapse = new bootstrap.Collapse(document.getElementById('collapseContact'), {
             toggle: true
         });
-    } else if (accountKind === 'Notes' || accountKind === 'Custom') {
+    } else if (accountKind === 'Notes' || accountKind === 'Custom' || editCategory === 'Notes' || editCategory === 'Custom') {
         const notesCollapse = new bootstrap.Collapse(document.getElementById('collapseNotes'), {
             toggle: true
         });
+    } else if (accountKind === 'Logins' || editCategory === 'Logins') {
+        const loginCollapse = new bootstrap.Collapse(document.getElementById('collapseLogin'), {
+            toggle: true
+        });
     }
 
     const editModal = new bootstrap.Modal(document.getElementById('editAccountModal'));
diff --git a/functional_tests/00_docker_start_server.sh b/functional_tests/00_docker_start_server.sh
index 74080c3..4ab52aa 100755
--- a/functional_tests/00_docker_start_server.sh
+++ b/functional_tests/00_docker_start_server.sh
@@ -1,5 +1,6 @@
 #!/bin/bash -e
 source env.sh
 
-docker run -p 8080:8080 -p 8443:8443 -e DEVICE_PEPPER_KEY=$DEVICE_PEPPER_KEY -e DATA_DIR=/data -e CERT_FILE=/data/cert-pass.pem -e KEY_FILE=/data/key-pass.pem -v $PARENT_DIR/PlexPassData:/data plexpass server
- 
+docker pull plexobject/plexpass
+docker run -p 8080:8080 -p 8443:8443 -e DEVICE_PEPPER_KEY=$DEVICE_PEPPER_KEY -e DATA_DIR=/data -e CERT_FILE=/data/cert-pass.pem -e KEY_FILE=/data/key-pass.pem -v $PARENT_DIR/PlexPassData:/data plexobject/plexpass server
+
diff --git a/src/controller/models.rs b/src/controller/models.rs
index fccce1e..c6dee30 100644
--- a/src/controller/models.rs
+++ b/src/controller/models.rs
@@ -362,7 +362,7 @@ impl CreateAccountRequest {
         if self.username.is_none() && self.email.is_none() && self.password.is_none() && self.notes.is_some() {
             return AccountKind::Notes;
         }
-        AccountKind::Login
+        AccountKind::Logins
     }
 
     pub fn to_account(&self) -> Account {
@@ -744,7 +744,7 @@ impl UpdateAccountRequest {
         if self.username.is_none() && self.email.is_none() && self.password.is_none() && self.notes.is_some() {
             return AccountKind::Notes;
         }
-        AccountKind::Login
+        AccountKind::Logins
     }
 
     pub fn to_account(&self) -> Account {
@@ -834,7 +834,7 @@ async fn load_string_from_multipart(field: &mut Field) -> PassResult<String> {
 
 impl Account {
     pub async fn from_multipart(payload: &mut Multipart, new_rec: bool, _config: &PassConfig) -> PassResult<Self> {
-        let mut account = Self::new("", AccountKind::Login);
+        let mut account = Self::new("", AccountKind::Logins);
         let mut custom_names = vec![];
         let mut custom_values = vec![];
         while let Some(item) = payload.next().await {
diff --git a/src/dao/account_repository_impl.rs b/src/dao/account_repository_impl.rs
index c38212c..ce8c67a 100644
--- a/src/dao/account_repository_impl.rs
+++ b/src/dao/account_repository_impl.rs
@@ -607,7 +607,7 @@ mod tests {
         assert_eq!(1, vault_repo.create(&ctx, &vault).await.unwrap());
 
         // WHEN creating an account
-        let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
 
         // THEN it should succeed
         assert_eq!(1, account_repo.create(&ctx, &account).await.unwrap());
@@ -654,7 +654,7 @@ mod tests {
         assert_eq!(1, vault_repo.create(&ctx, &vault).await.unwrap());
 
         // WHEN creating an account
-        let account = Account::new(&vault.vault_id, AccountKind::Login);
+        let account = Account::new(&vault.vault_id, AccountKind::Logins);
 
         // THEN it should succeed
         assert_eq!(1, account_repo.create(&ctx, &account).await.unwrap());
@@ -698,7 +698,7 @@ mod tests {
 
         for i in 0..3 {
             // WHEN creating an account
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             // THEN it should succeed only if value has is distinct
             if i == 0 {
                 assert_eq!(1, account_repo.create(&ctx, &account).await.unwrap());
diff --git a/src/dao/models.rs b/src/dao/models.rs
index e8f716d..2aced40 100644
--- a/src/dao/models.rs
+++ b/src/dao/models.rs
@@ -1766,7 +1766,7 @@ mod tests {
 
     #[test]
     fn test_should_create_account() {
-        let account = Account::new("vault0", AccountKind::Login);
+        let account = Account::new("vault0", AccountKind::Logins);
         let account_entity = AccountEntity::new(&account, "salt", "nonce", "enc-value");
         assert_ne!("", account_entity.account_id.as_str());
         assert_eq!("vault0", account_entity.vault_id.as_str());
@@ -1781,7 +1781,7 @@ mod tests {
 
     #[test]
     fn test_should_equal_account() {
-        let account = Account::new("vault0", AccountKind::Login);
+        let account = Account::new("vault0", AccountKind::Logins);
         let account_entity1 = AccountEntity::new(&account, "salt", "nonce", "enc-value");
         let account_entity2 = AccountEntity::new(&account, "salt", "nonce", "enc-value");
         assert_eq!(account_entity1, account_entity2);
@@ -1798,7 +1798,7 @@ mod tests {
         let ctx =
             UserContext::default_new(&user.username, &user.user_id, &salt, &pepper, "password")
                 .unwrap();
-        let account = Account::new("vault0", AccountKind::Login);
+        let account = Account::new("vault0", AccountKind::Logins);
         let account_entity = AccountEntity::new(&account, "salt", "nonce", "enc-value");
         let (crypto_key, _) =
             CryptoKeyEntity::new_with_input(&ctx, "pass", &user.user_id, "id", "type", "").unwrap();
@@ -1841,7 +1841,7 @@ mod tests {
         )
             .unwrap();
 
-        let mut account = Account::new("vault0", AccountKind::Login);
+        let mut account = Account::new("vault0", AccountKind::Logins);
         let (mut account_entity, account_crypto_key) = AccountEntity::from_context_vault_account(
             &ctx,
             &user_crypto_key,
diff --git a/src/dao/share_vault_account_repository_impl.rs b/src/dao/share_vault_account_repository_impl.rs
index ca37886..29182f1 100644
--- a/src/dao/share_vault_account_repository_impl.rs
+++ b/src/dao/share_vault_account_repository_impl.rs
@@ -410,7 +410,7 @@ mod tests {
 
         for i in 0..2 {
             // WHEN creating an account
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(format!("user_{}", i.clone()));
             account.details.email = Some(format!("email_{}@domain.io", i.clone()));
             account.credentials.password = Some(format!("pass_{}", i.clone()));
@@ -482,7 +482,7 @@ mod tests {
 
         // User 2 should also be able to create accounts for write permissions.
         for i in 0..2 {
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(format!("user_{}", i.clone()));
             account.details.email = Some(format!("email_{}@domain.io", i.clone()));
             account.credentials.password = Some(format!("pass_{}", i.clone()));
@@ -530,7 +530,7 @@ mod tests {
 
         for i in 0..2 {
             // WHEN creating an account
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(format!("user_{}", i.clone()));
             account.details.email = Some(format!("email_{}@domain.io", i.clone()));
             account.credentials.password = Some(format!("pass_{}", i.clone()));
@@ -598,7 +598,7 @@ mod tests {
 
         // User 2 should not be able to create accounts for read permissions.
         for i in 0..2 {
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(format!("user_{}", i.clone()));
             account.details.email = Some(format!("email_{}@domain.io", i.clone()));
             account.credentials.password = Some(format!("pass_{}", i.clone()));
@@ -645,7 +645,7 @@ mod tests {
 
         for i in 0..2 {
             // WHEN creating an account
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(format!("user_{}", i.clone()));
             account.details.email = Some(format!("email_{}@domain.io", i.clone()));
             account.credentials.password = Some(format!("pass_{}", i.clone()));
diff --git a/src/domain/args.rs b/src/domain/args.rs
index e00e80f..4188673 100644
--- a/src/domain/args.rs
+++ b/src/domain/args.rs
@@ -753,7 +753,7 @@ impl Args {
         } else if username.is_none() && email.is_none() && password.is_none() && notes.is_some() {
             AccountKind::Notes
         } else {
-            AccountKind::Login
+            AccountKind::Logins
         };
         let mut account = Account::new(vault_id, kind);
         account.details.label = label.clone();
diff --git a/src/domain/models.rs b/src/domain/models.rs
index 1033ec0..cac046f 100644
--- a/src/domain/models.rs
+++ b/src/domain/models.rs
@@ -763,8 +763,8 @@ impl From<&str> for SettingKind {
 
 #[derive(Debug, Clone, Eq, Serialize, Deserialize)]
 pub enum AccountKind {
-    Login,
-    Contact,
+    Logins,
+    Contacts,
     Notes,
     Custom,
 }
@@ -772,8 +772,8 @@ pub enum AccountKind {
 impl AccountKind {
     pub fn to_vault_kind(&self) -> VaultKind {
         match self {
-            AccountKind::Login => VaultKind::Logins,
-            AccountKind::Contact => VaultKind::Contacts,
+            AccountKind::Logins => VaultKind::Logins,
+            AccountKind::Contacts => VaultKind::Contacts,
             AccountKind::Notes => VaultKind::SecureNotes,
             AccountKind::Custom => VaultKind::Custom,
         }
@@ -783,8 +783,8 @@ impl AccountKind {
 impl Display for AccountKind {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            AccountKind::Login => write!(f, "Login"),
-            AccountKind::Contact => write!(f, "Contact"),
+            AccountKind::Logins => write!(f, "Logins"),
+            AccountKind::Contacts => write!(f, "Contacts"),
             AccountKind::Notes => write!(f, "Notes"),
             AccountKind::Custom => write!(f, "Custom"),
         }
@@ -800,7 +800,7 @@ impl PartialEq for AccountKind {
 impl From<&str> for AccountKind {
     fn from(s: &str) -> AccountKind {
         match s {
-            "Login" => AccountKind::Login,
+            "Login" => AccountKind::Logins,
             "Custom" => AccountKind::Custom,
             "Notes" => AccountKind::Notes,
             _ => {
@@ -810,7 +810,7 @@ impl From<&str> for AccountKind {
                 } else if s.contains("data") || s.contains("custom") || s.contains("form") {
                     AccountKind::Custom
                 } else {
-                    AccountKind::Login
+                    AccountKind::Logins
                 }
             }
         }
@@ -1404,7 +1404,7 @@ pub const DEFAULT_CATEGORIES: [&str; 10] = [
     "Gaming",
     "Notes",
     "Credit Cards",
-    "Miscellaneous",
+    "Custom",
 ];
 
 pub fn top_categories() -> Vec<String> {
@@ -2942,7 +2942,7 @@ mod tests {
 
     #[test]
     fn test_should_create_account() {
-        let account = Account::new("vault0", AccountKind::Login);
+        let account = Account::new("vault0", AccountKind::Logins);
         assert_ne!("", &account.details.account_id);
         assert_eq!("vault0", &account.vault_id);
         assert_eq!(0, account.details.version);
@@ -2969,7 +2969,7 @@ mod tests {
 
     #[test]
     fn test_should_validate_account() {
-        let mut account = Account::new("vault", AccountKind::Login);
+        let mut account = Account::new("vault", AccountKind::Logins);
         account.details.username = Some("user".into());
         account.details.website_url = Some("url".into());
         account.credentials.password = Some("pass".into());
@@ -2980,7 +2980,7 @@ mod tests {
 
     #[test]
     fn test_should_before_save_account() {
-        let mut account = Account::new("vault", AccountKind::Login);
+        let mut account = Account::new("vault", AccountKind::Logins);
         account.details.category = Some("login".into());
         account.details.tags = vec!["personal".into(), "work".into()];
         account.before_save();
@@ -2988,9 +2988,9 @@ mod tests {
 
     #[test]
     fn test_should_equal_account() {
-        let account1 = Account::new("vault1", AccountKind::Login);
-        let account2 = Account::new("vault1", AccountKind::Login);
-        let account3 = Account::new("vault1", AccountKind::Login);
+        let account1 = Account::new("vault1", AccountKind::Logins);
+        let account2 = Account::new("vault1", AccountKind::Logins);
+        let account3 = Account::new("vault1", AccountKind::Logins);
         assert_ne!(account1.details, account2.details);
         assert_ne!(account1.details, account3.details);
         let mut hasher = DefaultHasher::new();
diff --git a/src/service/account_service_impl.rs b/src/service/account_service_impl.rs
index 22cc96e..3937b32 100644
--- a/src/service/account_service_impl.rs
+++ b/src/service/account_service_impl.rs
@@ -127,7 +127,7 @@ mod tests {
         assert_eq!(1, vault_service.create_vault(&ctx, &vault).await.unwrap());
 
         // WHEN creating a new account
-        let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
         account.details.username = Some("user".into());
         account.credentials.password = Some("pass".into());
         // THEN it should succeed
@@ -182,7 +182,7 @@ mod tests {
         assert_eq!(1, vault_service.create_vault(&ctx, &vault).await.unwrap());
 
         // WHEN creating a new account
-        let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
         account.details.username = Some("user".into());
         account.credentials.password = Some("pass".into());
         // THEN it should succeed
@@ -230,7 +230,7 @@ mod tests {
 
         for i in 0..5 {
             // WHEN creating a new account
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(format!("user_{}", i));
             account.details.category = Some("cat1".into());
             account.details.tags = vec!["tag1".into(), "tag2".into()];
diff --git a/src/service/otp_service_impl.rs b/src/service/otp_service_impl.rs
index bb612c4..b8857d5 100644
--- a/src/service/otp_service_impl.rs
+++ b/src/service/otp_service_impl.rs
@@ -45,7 +45,7 @@ impl OTPServiceImpl {
                 .find(|(key, _)| key == "secret")
                 .map(|(_, value)| value.into_owned()) {
                 let mut account = AccountResponse::new(
-                    &Account::new("", AccountKind::Login));
+                    &Account::new("", AccountKind::Logins));
                 account.label = Some(url.domain().unwrap_or("").to_string());
                 account.otp = Some(secret.to_string());
                 account.generated_otp = Some(TOTP::new(secret).generate(30, 0));
diff --git a/src/service/password_service_impl.rs b/src/service/password_service_impl.rs
index ad4aae7..2486095 100644
--- a/src/service/password_service_impl.rs
+++ b/src/service/password_service_impl.rs
@@ -348,7 +348,7 @@ mod tests {
         for vault in vault_service.get_user_vaults(&ctx).await.unwrap() {
             for password in &passwords {
                 // WHEN creating a new account
-                let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+                let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
                 account.details.username = Some(format!("user_{}", password));
                 account.credentials.password = Some(password.to_string());
                 assert_eq!(1, account_service.create_account(&ctx, &account).await.unwrap());
@@ -382,51 +382,51 @@ mod tests {
 
 
         // AND Given three accounts with passwords
-        let mut account1 = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account1 = Account::new(&vault.vault_id, AccountKind::Logins);
         account1.details.label = Some("user1".into());
         account1.details.username = Some("user1".into());
         account1.credentials.password = Some("Rootbeer123".into());
         assert_eq!(1, account_service .create_account(&ctx, &account1).await.unwrap());
-        let mut account2 = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account2 = Account::new(&vault.vault_id, AccountKind::Logins);
         account2.details.label = Some("user2".into());
         account2.details.username = Some("user2".into());
         account2.credentials.password = Some("sMU{b+CMP76T9g^>".into());
         assert_eq!(1, account_service .create_account(&ctx, &account2).await.unwrap());
-        let mut account3 = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account3 = Account::new(&vault.vault_id, AccountKind::Logins);
         account3.details.label = Some("user3".into());
         account3.details.username = Some("user3".into());
         account3.credentials.password = Some("Rootbeer1".into());
         assert_eq!(1, account_service .create_account(&ctx, &account3).await.unwrap());
 
         // AND Given three accounts with usernames/emails but without passwords
-        let mut account4 = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account4 = Account::new(&vault.vault_id, AccountKind::Logins);
         account4.details.label = Some("user4".into());
         account4.details.username = Some("user4".into());
         assert_eq!(1, account_service .create_account(&ctx, &account4).await.unwrap());
-        let mut account5 = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account5 = Account::new(&vault.vault_id, AccountKind::Logins);
         account5.details.label = Some("user5".into());
         account5.details.email = Some("email5@bitvaulet.com".into());
         assert_eq!(1, account_service .create_account(&ctx, &account5).await.unwrap());
-        let mut account6 = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account6 = Account::new(&vault.vault_id, AccountKind::Logins);
         account6.details.phone = Some("phone6".into());
         account6.details.label = Some("user6".into());
         assert_eq!(1, account_service .create_account(&ctx, &account6).await.unwrap());
 
         // AND Given a account without anything and another with just label
-        let account7 = Account::new(&vault.vault_id, AccountKind::Login);
+        let account7 = Account::new(&vault.vault_id, AccountKind::Logins);
         assert_eq!(1, account_service .create_account(&ctx, &account7).await.unwrap());
-        let mut account8 = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account8 = Account::new(&vault.vault_id, AccountKind::Logins);
         account8.details.label = Some("user8".into());
         assert_eq!(1, account_service .create_account(&ctx, &account8).await.unwrap());
 
         // AND Given two accounts with notes
-        let mut account9 = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account9 = Account::new(&vault.vault_id, AccountKind::Logins);
         account9.details.label = Some("user9".into());
         account9.details.username = Some("user9".into());
         account9.credentials.notes = Some("note9".into());
         assert_eq!(1, account_service .create_account(&ctx, &account9).await.unwrap());
 
-        let mut account10 = Account::new(&vault.vault_id, AccountKind::Login);
+        let mut account10 = Account::new(&vault.vault_id, AccountKind::Logins);
         account10.details.label = Some("user10".into());
         account10.details.username = Some("user10".into());
         account10.credentials.notes = Some("note10".into());
diff --git a/src/service/share_vault_account_service_impl.rs b/src/service/share_vault_account_service_impl.rs
index 0e99324..57cf3a0 100644
--- a/src/service/share_vault_account_service_impl.rs
+++ b/src/service/share_vault_account_service_impl.rs
@@ -88,7 +88,7 @@ mod tests {
         // WHEN creating a new accounts
         let account_names = ["user1", "user2"];
         for account_name in account_names {
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(account_name.into());
             account.credentials.password = Some("pass".into());
             // THEN it should succeed
@@ -151,7 +151,7 @@ mod tests {
 
         // User 2 should also be able to create accounts for write permissions.
         for i in 0..2 {
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(format!("user_{}", i.clone()));
             account.details.email = Some(format!("email_{}@domain.io", i.clone()));
             account.credentials.password = Some(format!("pass_{}", i.clone()));
@@ -181,7 +181,7 @@ mod tests {
         // WHEN creating a new accounts
         let account_names = ["user1", "user2"];
         for account_name in account_names {
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(account_name.into());
             account.credentials.password = Some("pass".into());
             // THEN it should succeed
@@ -256,7 +256,7 @@ mod tests {
         // WHEN creating a new accounts
         let account_names = ["user1", "user2"];
         for account_name in account_names {
-            let mut account = Account::new(&vault.vault_id, AccountKind::Login);
+            let mut account = Account::new(&vault.vault_id, AccountKind::Logins);
             account.details.username = Some(account_name.into());
             account.credentials.password = Some("pass".into());
             // THEN it should succeed