diff --git a/examples/chip-tool/config/PersistentStorage.cpp b/examples/chip-tool/config/PersistentStorage.cpp
index 1ae0466abeb879..2170fd3b254fcd 100644
--- a/examples/chip-tool/config/PersistentStorage.cpp
+++ b/examples/chip-tool/config/PersistentStorage.cpp
@@ -53,11 +53,11 @@ CHIP_ERROR PersistentStorage::Init()
     return err;
 }
 
-void PersistentStorage::SetDelegate(PersistentStorageResultDelegate * delegate) {}
+void PersistentStorage::SetStorageDelegate(PersistentStorageResultDelegate * delegate) {}
 
-void PersistentStorage::GetKeyValue(const char * key) {}
+void PersistentStorage::AsyncGetKeyValue(const char * key) {}
 
-CHIP_ERROR PersistentStorage::GetKeyValue(const char * key, char * value, uint16_t & size)
+CHIP_ERROR PersistentStorage::SyncGetKeyValue(const char * key, char * value, uint16_t & size)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
     std::string iniValue;
@@ -79,7 +79,7 @@ CHIP_ERROR PersistentStorage::GetKeyValue(const char * key, char * value, uint16
     return err;
 }
 
-void PersistentStorage::SetKeyValue(const char * key, const char * value)
+void PersistentStorage::AsyncSetKeyValue(const char * key, const char * value)
 {
     auto section = mConfig.sections[kDefaultSectionName];
     section[key] = std::string(value);
@@ -88,7 +88,7 @@ void PersistentStorage::SetKeyValue(const char * key, const char * value)
     CommitConfig();
 }
 
-void PersistentStorage::DeleteKeyValue(const char * key)
+void PersistentStorage::AsyncDeleteKeyValue(const char * key)
 {
     auto section = mConfig.sections[kDefaultSectionName];
     section.erase(key);
@@ -126,7 +126,7 @@ uint16_t PersistentStorage::GetListenPort()
 
     char value[6];
     uint16_t size = static_cast<uint16_t>(sizeof(value));
-    err           = GetKeyValue(kPortKey, value, size);
+    err           = SyncGetKeyValue(kPortKey, value, size);
     if (CHIP_NO_ERROR == err)
     {
         uint16_t tmpValue;
@@ -148,7 +148,7 @@ LogCategory PersistentStorage::GetLoggingLevel()
 
     char value[9];
     uint16_t size = static_cast<uint16_t>(sizeof(value));
-    err           = GetKeyValue(kLoggingKey, value, size);
+    err           = SyncGetKeyValue(kLoggingKey, value, size);
     if (CHIP_NO_ERROR == err)
     {
         if (strcasecmp(value, "none") == 0)
diff --git a/examples/chip-tool/config/PersistentStorage.h b/examples/chip-tool/config/PersistentStorage.h
index edef1cdf94678c..85fc73fc394885 100644
--- a/examples/chip-tool/config/PersistentStorage.h
+++ b/examples/chip-tool/config/PersistentStorage.h
@@ -28,11 +28,11 @@ class PersistentStorage : public chip::PersistentStorageDelegate
     CHIP_ERROR Init();
 
     /////////// PersistentStorageDelegate Interface /////////
-    void SetDelegate(chip::PersistentStorageResultDelegate * delegate) override;
-    void GetKeyValue(const char * key) override;
-    CHIP_ERROR GetKeyValue(const char * key, char * value, uint16_t & size) override;
-    void SetKeyValue(const char * key, const char * value) override;
-    void DeleteKeyValue(const char * key) override;
+    void SetStorageDelegate(chip::PersistentStorageResultDelegate * delegate) override;
+    void AsyncGetKeyValue(const char * key) override;
+    CHIP_ERROR SyncGetKeyValue(const char * key, char * value, uint16_t & size) override;
+    void AsyncSetKeyValue(const char * key, const char * value) override;
+    void AsyncDeleteKeyValue(const char * key) override;
 
     uint16_t GetListenPort();
     chip::Logging::LogCategory GetLoggingLevel();
diff --git a/src/app/server/RendezvousServer.cpp b/src/app/server/RendezvousServer.cpp
index f8b8ff991d14f2..2e7fd5aa761a1c 100644
--- a/src/app/server/RendezvousServer.cpp
+++ b/src/app/server/RendezvousServer.cpp
@@ -74,7 +74,7 @@ void RendezvousServer::OnRendezvousComplete()
                    ChipLogError(AppServer, "Failed to store the connection state"));
 
     uint16_t nextKeyId = mRendezvousSession.GetNextKeyId();
-    mStorage->SetKeyValue(kStorablePeerConnectionCountKey, &nextKeyId, sizeof(nextKeyId));
+    mStorage->SyncSetKeyValue(kStorablePeerConnectionCountKey, &nextKeyId, sizeof(nextKeyId));
 }
 
 void RendezvousServer::OnRendezvousStatusUpdate(Status status, CHIP_ERROR err)
diff --git a/src/app/server/Server.cpp b/src/app/server/Server.cpp
index fa10c5446d3a2f..b34bd6068a7e64 100644
--- a/src/app/server/Server.cpp
+++ b/src/app/server/Server.cpp
@@ -72,35 +72,35 @@ constexpr bool useTestPairing()
 
 class ServerStorageDelegate : public PersistentStorageDelegate
 {
-    void SetDelegate(PersistentStorageResultDelegate * delegate) override
+    void SetStorageDelegate(PersistentStorageResultDelegate * delegate) override
     {
         ChipLogError(AppServer, "ServerStorageDelegate does not support async operations");
         chipDie();
     }
 
-    void GetKeyValue(const char * key) override
+    void AsyncGetKeyValue(const char * key) override
     {
         ChipLogError(AppServer, "ServerStorageDelegate does not support async operations");
         chipDie();
     }
 
-    void SetKeyValue(const char * key, const char * value) override
+    void AsyncSetKeyValue(const char * key, const char * value) override
     {
         ChipLogError(AppServer, "ServerStorageDelegate does not support async operations");
         chipDie();
     }
 
-    CHIP_ERROR GetKeyValue(const char * key, void * buffer, uint16_t & size) override
+    CHIP_ERROR SyncGetKeyValue(const char * key, void * buffer, uint16_t & size) override
     {
         return PersistedStorage::KeyValueStoreMgr().Get(key, buffer, size);
     }
 
-    CHIP_ERROR SetKeyValue(const char * key, const void * value, uint16_t size) override
+    CHIP_ERROR SyncSetKeyValue(const char * key, const void * value, uint16_t size) override
     {
         return PersistedStorage::KeyValueStoreMgr().Put(key, value, size);
     }
 
-    void DeleteKeyValue(const char * key) override { PersistedStorage::KeyValueStoreMgr().Delete(key); }
+    void AsyncDeleteKeyValue(const char * key) override { PersistedStorage::KeyValueStoreMgr().Delete(key); }
 };
 
 ServerStorageDelegate gServerStorage;
diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp
index d9117daf281cc3..92b954f4346128 100644
--- a/src/controller/CHIPDeviceController.cpp
+++ b/src/controller/CHIPDeviceController.cpp
@@ -126,7 +126,7 @@ CHIP_ERROR DeviceController::Init(NodeId localDeviceId, PersistentStorageDelegat
 
     if (mStorageDelegate != nullptr)
     {
-        mStorageDelegate->SetDelegate(this);
+        mStorageDelegate->SetStorageDelegate(this);
     }
 
     mTransportMgr   = chip::Platform::New<DeviceTransportMgr>();
@@ -193,7 +193,7 @@ CHIP_ERROR DeviceController::Shutdown()
 
     if (mStorageDelegate != nullptr)
     {
-        mStorageDelegate->SetDelegate(nullptr);
+        mStorageDelegate->SetStorageDelegate(nullptr);
         mStorageDelegate = nullptr;
     }
 
@@ -287,7 +287,7 @@ CHIP_ERROR DeviceController::GetDevice(NodeId deviceId, Device ** out_device)
             VerifyOrExit(buffer != nullptr, err = CHIP_ERROR_INVALID_ARGUMENT);
 
             PERSISTENT_KEY_OP(static_cast<uint64_t>(0), kPairedDeviceListKeyPrefix, key,
-                              err = mStorageDelegate->GetKeyValue(key, buffer, size));
+                              err = mStorageDelegate->SyncGetKeyValue(key, buffer, size));
             SuccessOrExit(err);
             VerifyOrExit(size <= max_size, err = CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR);
 
@@ -306,7 +306,7 @@ CHIP_ERROR DeviceController::GetDevice(NodeId deviceId, Device ** out_device)
             uint16_t size = sizeof(deviceInfo.inner);
 
             PERSISTENT_KEY_OP(deviceId, kPairedDeviceKeyPrefix, key,
-                              err = mStorageDelegate->GetKeyValue(key, Uint8::to_char(deviceInfo.inner), size));
+                              err = mStorageDelegate->SyncGetKeyValue(key, Uint8::to_char(deviceInfo.inner), size));
             SuccessOrExit(err);
             VerifyOrExit(size <= sizeof(deviceInfo.inner), err = CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR);
 
@@ -485,9 +485,9 @@ CHIP_ERROR DeviceController::SetPairedDeviceList(const char * serialized)
     return err;
 }
 
-void DeviceController::OnValue(const char * key, const char * value) {}
+void DeviceController::OnPersistentStorageValue(const char * key, const char * value) {}
 
-void DeviceController::OnStatus(const char * key, Operation op, CHIP_ERROR err) {}
+void DeviceController::OnPersistentStorageStatus(const char * key, Operation op, CHIP_ERROR err) {}
 
 DeviceCommissioner::DeviceCommissioner()
 {
@@ -671,7 +671,7 @@ CHIP_ERROR DeviceCommissioner::UnpairDevice(NodeId remoteDeviceId)
 
     if (mStorageDelegate != nullptr)
     {
-        PERSISTENT_KEY_OP(remoteDeviceId, kPairedDeviceKeyPrefix, key, mStorageDelegate->DeleteKeyValue(key));
+        PERSISTENT_KEY_OP(remoteDeviceId, kPairedDeviceKeyPrefix, key, mStorageDelegate->AsyncDeleteKeyValue(key));
     }
 
     mPairedDevices.Remove(remoteDeviceId);
@@ -733,7 +733,7 @@ void DeviceCommissioner::OnRendezvousComplete()
         SerializedDevice serialized;
         device->Serialize(serialized);
         PERSISTENT_KEY_OP(device->GetDeviceId(), kPairedDeviceKeyPrefix, key,
-                          mStorageDelegate->SetKeyValue(key, Uint8::to_const_char(serialized.inner)));
+                          mStorageDelegate->AsyncSetKeyValue(key, Uint8::to_const_char(serialized.inner)));
     }
 
     RendezvousCleanup(CHIP_NO_ERROR);
@@ -796,7 +796,7 @@ void DeviceCommissioner::PersistDeviceList()
             if (value != nullptr && requiredSize <= size)
             {
                 PERSISTENT_KEY_OP(static_cast<uint64_t>(0), kPairedDeviceListKeyPrefix, key,
-                                  mStorageDelegate->SetKeyValue(key, value));
+                                  mStorageDelegate->AsyncSetKeyValue(key, value));
                 mPairedDevicesUpdated = false;
             }
             chip::Platform::MemoryFree(serialized);
diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h
index 1e9c75c2cf514f..98cf13955eda79 100644
--- a/src/controller/CHIPDeviceController.h
+++ b/src/controller/CHIPDeviceController.h
@@ -213,8 +213,8 @@ class DLL_EXPORT DeviceController : public SecureSessionMgrDelegate, public Pers
     void OnConnectionExpired(SecureSessionHandle session, SecureSessionMgr * mgr) override;
 
     //////////// PersistentStorageResultDelegate Implementation ///////////////
-    void OnValue(const char * key, const char * value) override;
-    void OnStatus(const char * key, Operation op, CHIP_ERROR err) override;
+    void OnPersistentStorageValue(const char * key, const char * value) override;
+    void OnPersistentStorageStatus(const char * key, Operation op, CHIP_ERROR err) override;
 
     void ReleaseAllDevices();
 
diff --git a/src/controller/java/AndroidDeviceControllerWrapper.cpp b/src/controller/java/AndroidDeviceControllerWrapper.cpp
index 0ea3b104066286..e9b2d26440a3b0 100644
--- a/src/controller/java/AndroidDeviceControllerWrapper.cpp
+++ b/src/controller/java/AndroidDeviceControllerWrapper.cpp
@@ -284,19 +284,19 @@ void AndroidDeviceControllerWrapper::OnMessage(chip::System::PacketBufferHandle
 
 void AndroidDeviceControllerWrapper::OnStatusChange(void) {}
 
-void AndroidDeviceControllerWrapper::SetDelegate(PersistentStorageResultDelegate * delegate)
+void AndroidDeviceControllerWrapper::SetStorageDelegate(PersistentStorageResultDelegate * delegate)
 {
     mStorageResultDelegate = delegate;
 }
 
-void AndroidDeviceControllerWrapper::GetKeyValue(const char * key)
+void AndroidDeviceControllerWrapper::AsyncGetKeyValue(const char * key)
 {
-    jstring keyString   = NULL;
-    jstring valueString = NULL;
-    const char * valueChars   = nullptr;
-    CHIP_ERROR err      = CHIP_NO_ERROR;
-    jclass storageCls   = GetPersistentStorageClass();
-    jmethodID method    = GetJavaEnv()->GetStaticMethodID(storageCls, "getKeyValue", "(Ljava/lang/String;)Ljava/lang/String;");
+    jstring keyString       = NULL;
+    jstring valueString     = NULL;
+    const char * valueChars = nullptr;
+    CHIP_ERROR err          = CHIP_NO_ERROR;
+    jclass storageCls       = GetPersistentStorageClass();
+    jmethodID method        = GetJavaEnv()->GetStaticMethodID(storageCls, "getKeyValue", "(Ljava/lang/String;)Ljava/lang/String;");
 
     GetJavaEnv()->ExceptionClear();
 
@@ -308,26 +308,27 @@ void AndroidDeviceControllerWrapper::GetKeyValue(const char * key)
     if (mStorageResultDelegate)
     {
         valueChars = GetJavaEnv()->GetStringUTFChars(valueString, 0);
-        mStorageResultDelegate->OnValue(key, valueChars);
+        mStorageResultDelegate->OnPersistentStorageValue(key, valueChars);
     }
 
 exit:
     GetJavaEnv()->ExceptionClear();
-    if (valueChars != nullptr) {
+    if (valueChars != nullptr)
+    {
         GetJavaEnv()->ReleaseStringUTFChars(valueString, valueChars);
     }
     GetJavaEnv()->DeleteLocalRef(keyString);
     GetJavaEnv()->DeleteLocalRef(valueString);
 }
 
-CHIP_ERROR AndroidDeviceControllerWrapper::GetKeyValue(const char * key, char * value, uint16_t & size)
+CHIP_ERROR AndroidDeviceControllerWrapper::SyncGetKeyValue(const char * key, char * value, uint16_t & size)
 {
-    jstring keyString   = NULL;
-    jstring valueString = NULL;
-    const char * valueChars   = nullptr;
-    CHIP_ERROR err      = CHIP_NO_ERROR;
-    jclass storageCls   = GetPersistentStorageClass();
-    jmethodID method    = GetJavaEnv()->GetStaticMethodID(storageCls, "getKeyValue", "(Ljava/lang/String;)Ljava/lang/String;");
+    jstring keyString       = NULL;
+    jstring valueString     = NULL;
+    const char * valueChars = nullptr;
+    CHIP_ERROR err          = CHIP_NO_ERROR;
+    jclass storageCls       = GetPersistentStorageClass();
+    jmethodID method        = GetJavaEnv()->GetStaticMethodID(storageCls, "getKeyValue", "(Ljava/lang/String;)Ljava/lang/String;");
 
     GetJavaEnv()->ExceptionClear();
 
@@ -341,7 +342,7 @@ CHIP_ERROR AndroidDeviceControllerWrapper::GetKeyValue(const char * key, char *
         if (value != nullptr)
         {
             valueChars = GetJavaEnv()->GetStringUTFChars(valueString, 0);
-            size = strlcpy(value, GetJavaEnv()->GetStringUTFChars(valueString, 0), size);
+            size       = strlcpy(value, GetJavaEnv()->GetStringUTFChars(valueString, 0), size);
         }
         else
         {
@@ -357,7 +358,8 @@ CHIP_ERROR AndroidDeviceControllerWrapper::GetKeyValue(const char * key, char *
 
 exit:
     GetJavaEnv()->ExceptionClear();
-    if (valueChars != nullptr) {
+    if (valueChars != nullptr)
+    {
         GetJavaEnv()->ReleaseStringUTFChars(valueString, valueChars);
     }
     GetJavaEnv()->DeleteLocalRef(keyString);
@@ -365,7 +367,7 @@ CHIP_ERROR AndroidDeviceControllerWrapper::GetKeyValue(const char * key, char *
     return err;
 }
 
-void AndroidDeviceControllerWrapper::SetKeyValue(const char * key, const char * value)
+void AndroidDeviceControllerWrapper::AsyncSetKeyValue(const char * key, const char * value)
 {
     jclass storageCls = GetPersistentStorageClass();
     jmethodID method  = GetJavaEnv()->GetStaticMethodID(storageCls, "setKeyValue", "(Ljava/lang/String;Ljava/lang/String;)V");
@@ -385,7 +387,7 @@ void AndroidDeviceControllerWrapper::SetKeyValue(const char * key, const char *
 
     if (mStorageResultDelegate)
     {
-        mStorageResultDelegate->OnStatus(key, PersistentStorageResultDelegate::Operation::kSET, CHIP_NO_ERROR);
+        mStorageResultDelegate->OnPersistentStorageStatus(key, PersistentStorageResultDelegate::Operation::kSET, CHIP_NO_ERROR);
     }
 
 exit:
@@ -394,7 +396,7 @@ void AndroidDeviceControllerWrapper::SetKeyValue(const char * key, const char *
     GetJavaEnv()->DeleteLocalRef(valueString);
 }
 
-void AndroidDeviceControllerWrapper::DeleteKeyValue(const char * key)
+void AndroidDeviceControllerWrapper::AsyncDeleteKeyValue(const char * key)
 {
     jclass storageCls = GetPersistentStorageClass();
     jmethodID method  = GetJavaEnv()->GetStaticMethodID(storageCls, "deleteKeyValue", "(Ljava/lang/String;)V");
@@ -411,7 +413,7 @@ void AndroidDeviceControllerWrapper::DeleteKeyValue(const char * key)
 
     if (mStorageResultDelegate)
     {
-        mStorageResultDelegate->OnStatus(key, PersistentStorageResultDelegate::Operation::kDELETE, CHIP_NO_ERROR);
+        mStorageResultDelegate->OnPersistentStorageStatus(key, PersistentStorageResultDelegate::Operation::kDELETE, CHIP_NO_ERROR);
     }
 
 exit:
diff --git a/src/controller/java/AndroidDeviceControllerWrapper.h b/src/controller/java/AndroidDeviceControllerWrapper.h
index 5d5b2a12416825..7f8f7ffd0fa235 100644
--- a/src/controller/java/AndroidDeviceControllerWrapper.h
+++ b/src/controller/java/AndroidDeviceControllerWrapper.h
@@ -56,11 +56,11 @@ class AndroidDeviceControllerWrapper : public chip::Controller::DevicePairingDel
     void OnStatusChange(void) override;
 
     // PersistentStorageDelegate implementation
-    void SetDelegate(chip::PersistentStorageResultDelegate * delegate) override;
-    void GetKeyValue(const char * key) override;
-    CHIP_ERROR GetKeyValue(const char * key, char * value, uint16_t & size) override;
-    void SetKeyValue(const char * key, const char * value) override;
-    void DeleteKeyValue(const char * key) override;
+    void SetStorageDelegate(chip::PersistentStorageResultDelegate * delegate) override;
+    void AsyncGetKeyValue(const char * key) override;
+    CHIP_ERROR SyncGetKeyValue(const char * key, char * value, uint16_t & size) override;
+    void AsyncSetKeyValue(const char * key, const char * value) override;
+    void AsyncDeleteKeyValue(const char * key) override;
 
     jlong ToJNIHandle()
     {
diff --git a/src/controller/python/ChipDeviceController-StorageDelegate.cpp b/src/controller/python/ChipDeviceController-StorageDelegate.cpp
index d71d199c2f99fe..9873263a775c68 100644
--- a/src/controller/python/ChipDeviceController-StorageDelegate.cpp
+++ b/src/controller/python/ChipDeviceController-StorageDelegate.cpp
@@ -29,24 +29,24 @@
 namespace chip {
 namespace Controller {
 
-void PythonPersistentStorageDelegate::SetDelegate(PersistentStorageResultDelegate * delegate)
+void PythonPersistentStorageDelegate::SetStorageDelegate(PersistentStorageResultDelegate * delegate)
 {
     mDelegate = delegate;
 }
 
-void PythonPersistentStorageDelegate::GetKeyValue(const char * key)
+void PythonPersistentStorageDelegate::AsyncGetKeyValue(const char * key)
 {
     auto val = mStorage.find(key);
     if (val == mStorage.end())
     {
-        mDelegate->OnStatus(key, PersistentStorageResultDelegate::Operation::kGET, CHIP_ERROR_KEY_NOT_FOUND);
+        mDelegate->OnPersistentStorageStatus(key, PersistentStorageResultDelegate::Operation::kGET, CHIP_ERROR_KEY_NOT_FOUND);
         return;
     }
 
-    mDelegate->OnValue(key, val->second.c_str());
+    mDelegate->OnPersistentStorageValue(key, val->second.c_str());
 }
 
-CHIP_ERROR PythonPersistentStorageDelegate::GetKeyValue(const char * key, char * value, uint16_t & size)
+CHIP_ERROR PythonPersistentStorageDelegate::SyncGetKeyValue(const char * key, char * value, uint16_t & size)
 {
     auto val = mStorage.find(key);
     if (val == mStorage.end())
@@ -79,17 +79,17 @@ CHIP_ERROR PythonPersistentStorageDelegate::GetKeyValue(const char * key, char *
     return CHIP_NO_ERROR;
 }
 
-void PythonPersistentStorageDelegate::SetKeyValue(const char * key, const char * value)
+void PythonPersistentStorageDelegate::AsyncSetKeyValue(const char * key, const char * value)
 {
     mStorage[key] = value;
-    ChipLogDetail(Controller, "SetKeyValue: %s=%s", key, value);
-    mDelegate->OnStatus(key, PersistentStorageResultDelegate::Operation::kSET, CHIP_NO_ERROR);
+    ChipLogDetail(Controller, "AsyncSetKeyValue: %s=%s", key, value);
+    mDelegate->OnPersistentStorageStatus(key, PersistentStorageResultDelegate::Operation::kSET, CHIP_NO_ERROR);
 }
 
-void PythonPersistentStorageDelegate::DeleteKeyValue(const char * key)
+void PythonPersistentStorageDelegate::AsyncDeleteKeyValue(const char * key)
 {
     mStorage.erase(key);
-    mDelegate->OnStatus(key, PersistentStorageResultDelegate::Operation::kDELETE, CHIP_NO_ERROR);
+    mDelegate->OnPersistentStorageStatus(key, PersistentStorageResultDelegate::Operation::kDELETE, CHIP_NO_ERROR);
 }
 
 } // namespace Controller
diff --git a/src/controller/python/ChipDeviceController-StorageDelegate.h b/src/controller/python/ChipDeviceController-StorageDelegate.h
index ee4a5a0165f4f4..9a1da8aadd39e3 100644
--- a/src/controller/python/ChipDeviceController-StorageDelegate.h
+++ b/src/controller/python/ChipDeviceController-StorageDelegate.h
@@ -36,11 +36,11 @@ class PythonPersistentStorageDelegate : public PersistentStorageDelegate
 {
 public:
     PythonPersistentStorageDelegate() {}
-    void SetDelegate(PersistentStorageResultDelegate * delegate) override;
-    void GetKeyValue(const char * key) override;
-    CHIP_ERROR GetKeyValue(const char * key, char * value, uint16_t & size) override;
-    void SetKeyValue(const char * key, const char * value) override;
-    void DeleteKeyValue(const char * key) override;
+    void SetStorageDelegate(PersistentStorageResultDelegate * delegate) override;
+    void AsyncGetKeyValue(const char * key) override;
+    CHIP_ERROR SyncGetKeyValue(const char * key, char * value, uint16_t & size) override;
+    void AsyncSetKeyValue(const char * key, const char * value) override;
+    void AsyncDeleteKeyValue(const char * key) override;
 
 private:
     PersistentStorageResultDelegate * mDelegate;
diff --git a/src/controller/python/chip/internal/CommissionerImpl.cpp b/src/controller/python/chip/internal/CommissionerImpl.cpp
index e03594b6b816d6..071ab7e43b0c0b 100644
--- a/src/controller/python/chip/internal/CommissionerImpl.cpp
+++ b/src/controller/python/chip/internal/CommissionerImpl.cpp
@@ -28,51 +28,51 @@ namespace {
 class ServerStorageDelegate : public chip::PersistentStorageDelegate
 {
 public:
-    void SetDelegate(chip::PersistentStorageResultDelegate * delegate) override { mAsyncDelegate = delegate; }
+    void SetStorageDelegate(chip::PersistentStorageResultDelegate * delegate) override { mAsyncDelegate = delegate; }
 
-    void GetKeyValue(const char * key) override
+    void AsyncGetKeyValue(const char * key) override
     {
         // TODO: Async Get/Set are implemented synchronously here.
         // We need to figure out a standard way to implement this - this implementation
         // was based on an example that just returned and that seemed even less useful.
         uint8_t buffer[kMaxKeyValueSize];
         uint16_t bufferSize = sizeof(buffer) - 1;
-        CHIP_ERROR err      = GetKeyValue(key, buffer, bufferSize);
+        CHIP_ERROR err      = SyncGetKeyValue(key, buffer, bufferSize);
 
         if (err == CHIP_NO_ERROR)
         {
             buffer[bufferSize] = 0;
-            mAsyncDelegate->OnValue(key, reinterpret_cast<const char *>(buffer));
+            mAsyncDelegate->OnPersistentStorageValue(key, reinterpret_cast<const char *>(buffer));
         }
         else
         {
-            mAsyncDelegate->OnStatus(key, chip::PersistentStorageResultDelegate::Operation::kGET, err);
+            mAsyncDelegate->OnPersistentStorageStatus(key, chip::PersistentStorageResultDelegate::Operation::kGET, err);
         }
     }
 
-    void SetKeyValue(const char * key, const char * value) override
+    void AsyncSetKeyValue(const char * key, const char * value) override
     {
 
-        CHIP_ERROR err = SetKeyValue(key, value, strlen(value));
+        CHIP_ERROR err = SyncSetKeyValue(key, value, strlen(value));
 
         if (err != CHIP_NO_ERROR)
         {
-            mAsyncDelegate->OnStatus(key, chip::PersistentStorageResultDelegate::Operation::kSET, err);
+            mAsyncDelegate->OnPersistentStorageStatus(key, chip::PersistentStorageResultDelegate::Operation::kSET, err);
         }
     }
 
     CHIP_ERROR
-    GetKeyValue(const char * key, void * buffer, uint16_t & size) override
+    SyncGetKeyValue(const char * key, void * buffer, uint16_t & size) override
     {
         return chip::DeviceLayer::PersistedStorage::KeyValueStoreMgr().Get(key, buffer, size);
     }
 
-    CHIP_ERROR SetKeyValue(const char * key, const void * value, uint16_t size) override
+    CHIP_ERROR SyncSetKeyValue(const char * key, const void * value, uint16_t size) override
     {
         return chip::DeviceLayer::PersistedStorage::KeyValueStoreMgr().Put(key, value, size);
     }
 
-    void DeleteKeyValue(const char * key) override { chip::DeviceLayer::PersistedStorage::KeyValueStoreMgr().Delete(key); }
+    void AsyncDeleteKeyValue(const char * key) override { chip::DeviceLayer::PersistedStorage::KeyValueStoreMgr().Delete(key); }
 
 private:
     static constexpr size_t kMaxKeyValueSize = 1024;
diff --git a/src/darwin/Framework/CHIP/CHIPDeviceController.mm b/src/darwin/Framework/CHIP/CHIPDeviceController.mm
index 35132172d03404..469d7b41064686 100644
--- a/src/darwin/Framework/CHIP/CHIPDeviceController.mm
+++ b/src/darwin/Framework/CHIP/CHIPDeviceController.mm
@@ -167,11 +167,11 @@ - (NSNumber *)_getControllerNodeId
     uint16_t idStringLen = 32;
     char deviceIdString[idStringLen];
     if (CHIP_NO_ERROR
-        != _persistentStorageDelegateBridge->GetKeyValue(CHIP_COMMISSIONER_DEVICE_ID_KEY, deviceIdString, idStringLen)) {
+        != _persistentStorageDelegateBridge->SyncGetKeyValue(CHIP_COMMISSIONER_DEVICE_ID_KEY, deviceIdString, idStringLen)) {
         _localDeviceId = arc4random();
         _localDeviceId = _localDeviceId << 32 | arc4random();
         CHIP_LOG_ERROR("Assigned %llx node ID to the controller", _localDeviceId);
-        _persistentStorageDelegateBridge->SetKeyValue(
+        _persistentStorageDelegateBridge->AsyncSetKeyValue(
             CHIP_COMMISSIONER_DEVICE_ID_KEY, [[NSString stringWithFormat:@"%llx", _localDeviceId] UTF8String]);
     } else {
         NSScanner * scanner = [NSScanner scannerWithString:[NSString stringWithUTF8String:deviceIdString]];
diff --git a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.h b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.h
index 58941447e1487c..144ff0a80ae4c6 100644
--- a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.h
+++ b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.h
@@ -30,15 +30,15 @@ class CHIPPersistentStorageDelegateBridge : public chip::PersistentStorageDelega
 
     void setFrameworkDelegate(id<CHIPPersistentStorageDelegate> delegate, dispatch_queue_t queue);
 
-    void SetDelegate(chip::PersistentStorageResultDelegate * delegate) override;
+    void SetStorageDelegate(chip::PersistentStorageResultDelegate * delegate) override;
 
-    void GetKeyValue(const char * key) override;
+    void AsyncGetKeyValue(const char * key) override;
 
-    CHIP_ERROR GetKeyValue(const char * key, char * value, uint16_t & size) override;
+    CHIP_ERROR SyncGetKeyValue(const char * key, char * value, uint16_t & size) override;
 
-    void SetKeyValue(const char * key, const char * value) override;
+    void AsyncSetKeyValue(const char * key, const char * value) override;
 
-    void DeleteKeyValue(const char * key) override;
+    void AsyncDeleteKeyValue(const char * key) override;
 
 private:
     id<CHIPPersistentStorageDelegate> mDelegate;
diff --git a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.mm b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.mm
index dcbe4a3298b7f5..0222ef3fd42b03 100644
--- a/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.mm
+++ b/src/darwin/Framework/CHIP/CHIPPersistentStorageDelegateBridge.mm
@@ -39,7 +39,7 @@
     });
 }
 
-void CHIPPersistentStorageDelegateBridge::SetDelegate(chip::PersistentStorageResultDelegate * delegate)
+void CHIPPersistentStorageDelegateBridge::SetStorageDelegate(chip::PersistentStorageResultDelegate * delegate)
 {
     dispatch_async(mWorkQueue, ^{
         if (delegate) {
@@ -49,7 +49,7 @@
                 chip::PersistentStorageResultDelegate * callback = mCallback;
                 if (callback) {
                     dispatch_async(mWorkQueue, ^{
-                        callback->OnValue([key UTF8String], [value UTF8String]);
+                        callback->OnPeristentStorageValue([key UTF8String], [value UTF8String]);
                     });
                 }
             };
@@ -58,7 +58,7 @@
                 chip::PersistentStorageResultDelegate * callback = mCallback;
                 if (callback) {
                     dispatch_async(mWorkQueue, ^{
-                        callback->OnStatus([key UTF8String], chip::PersistentStorageResultDelegate::Operation::kSET,
+                        callback->OnPeristentStorageStatus([key UTF8String], chip::PersistentStorageResultDelegate::Operation::kSET,
                             [CHIPError errorToCHIPErrorCode:status]);
                     });
                 }
@@ -68,8 +68,8 @@
                 chip::PersistentStorageResultDelegate * callback = mCallback;
                 if (callback) {
                     dispatch_async(mWorkQueue, ^{
-                        callback->OnStatus([key UTF8String], chip::PersistentStorageResultDelegate::Operation::kDELETE,
-                            [CHIPError errorToCHIPErrorCode:status]);
+                        callback->OnPeristentStorageStatus([key UTF8String],
+                            chip::PersistentStorageResultDelegate::Operation::kDELETE, [CHIPError errorToCHIPErrorCode:status]);
                     });
                 }
             };
@@ -82,7 +82,7 @@
     });
 }
 
-void CHIPPersistentStorageDelegateBridge::GetKeyValue(const char * key)
+void CHIPPersistentStorageDelegateBridge::AsyncGetKeyValue(const char * key)
 {
     NSString * keyString = [NSString stringWithUTF8String:key];
     dispatch_async(mWorkQueue, ^{
@@ -103,7 +103,7 @@
     });
 }
 
-CHIP_ERROR CHIPPersistentStorageDelegateBridge::GetKeyValue(const char * key, char * value, uint16_t & size)
+CHIP_ERROR CHIPPersistentStorageDelegateBridge::SyncGetKeyValue(const char * key, char * value, uint16_t & size)
 {
     __block CHIP_ERROR error = CHIP_NO_ERROR;
     NSString * keyString = [NSString stringWithUTF8String:key];
@@ -138,7 +138,7 @@
     return error;
 }
 
-void CHIPPersistentStorageDelegateBridge::SetKeyValue(const char * key, const char * value)
+void CHIPPersistentStorageDelegateBridge::AsyncSetKeyValue(const char * key, const char * value)
 {
     NSString * keyString = [NSString stringWithUTF8String:key];
     NSString * valueString = [NSString stringWithUTF8String:value];
@@ -159,7 +159,7 @@
     });
 }
 
-void CHIPPersistentStorageDelegateBridge::DeleteKeyValue(const char * key)
+void CHIPPersistentStorageDelegateBridge::AsyncDeleteKeyValue(const char * key)
 {
     NSString * keyString = [NSString stringWithUTF8String:key];
     dispatch_async(mWorkQueue, ^{
diff --git a/src/lib/core/CHIPPersistentStorageDelegate.h b/src/lib/core/CHIPPersistentStorageDelegate.h
index 4e922acaaabe0f..f94b9f10cca6a5 100644
--- a/src/lib/core/CHIPPersistentStorageDelegate.h
+++ b/src/lib/core/CHIPPersistentStorageDelegate.h
@@ -38,12 +38,12 @@ class DLL_EXPORT PersistentStorageResultDelegate
     /**
      * @brief
      *   Called when a value is returned from the storage.
-     *   This is useful for GetKeyValue() API call.
+     *   This is useful for AsyncGetKeyValue() API call.
      *
      * @param[in] key Key for which the value is being returned
      * @param[in] value Value or nullptr if not found.
      */
-    virtual void OnValue(const char * key, const char * value) = 0;
+    virtual void OnPersistentStorageValue(const char * key, const char * value) = 0;
 
     /**
      * @brief
@@ -53,7 +53,7 @@ class DLL_EXPORT PersistentStorageResultDelegate
      * @param[in] op Operation that was being performed on the key
      * @param[in] result CHIP_NO_ERROR or corresponding error code
      */
-    virtual void OnStatus(const char * key, Operation op, CHIP_ERROR result) = 0;
+    virtual void OnPersistentStorageStatus(const char * key, Operation op, CHIP_ERROR result) = 0;
 };
 
 class DLL_EXPORT PersistentStorageDelegate
@@ -68,7 +68,7 @@ class DLL_EXPORT PersistentStorageDelegate
      *
      * @param[in] delegate The callback object
      */
-    virtual void SetDelegate(PersistentStorageResultDelegate * delegate) = 0;
+    virtual void SetStorageDelegate(PersistentStorageResultDelegate * delegate) = 0;
 
     /**
      * @brief
@@ -76,7 +76,7 @@ class DLL_EXPORT PersistentStorageDelegate
      *
      * @param[in] key Key to lookup
      */
-    virtual void GetKeyValue(const char * key) = 0;
+    virtual void AsyncGetKeyValue(const char * key) = 0;
 
     /**
      * @brief
@@ -95,7 +95,7 @@ class DLL_EXPORT PersistentStorageDelegate
      *                 The output size could be larger than input value. In
      *                 such cases, the user should allocate the buffer large
      *                 enough (>= output size), and call the API again.  In this
-     *                 case GetKeyValue will place as many bytes as it can in
+     *                 case SyncGetKeyValue will place as many bytes as it can in
      *                 the buffer and return CHIP_ERROR_NO_MEMORY.
      *
      *                 If value is null, the input size is treated as 0.
@@ -104,7 +104,7 @@ class DLL_EXPORT PersistentStorageDelegate
      * @return CHIP_ERROR_NO_MEMORY if the input buffer is not big enough for
      *                              the value.
      */
-    virtual CHIP_ERROR GetKeyValue(const char * key, char * value, uint16_t & size) { return CHIP_ERROR_NOT_IMPLEMENTED; }
+    virtual CHIP_ERROR SyncGetKeyValue(const char * key, char * value, uint16_t & size) { return CHIP_ERROR_NOT_IMPLEMENTED; }
 
     /**
      * @brief
@@ -121,7 +121,7 @@ class DLL_EXPORT PersistentStorageDelegate
      *                 such cases, the user should allocate the buffer large
      *                 enough (>= output length), and call the API again.
      */
-    virtual CHIP_ERROR GetKeyValue(const char * key, void * buffer, uint16_t & size) { return CHIP_ERROR_NOT_IMPLEMENTED; }
+    virtual CHIP_ERROR SyncGetKeyValue(const char * key, void * buffer, uint16_t & size) { return CHIP_ERROR_NOT_IMPLEMENTED; }
 
     /**
      * @brief
@@ -130,7 +130,7 @@ class DLL_EXPORT PersistentStorageDelegate
      * @param[in] key Key to be set
      * @param[in] value Value to be set
      */
-    virtual void SetKeyValue(const char * key, const char * value) = 0;
+    virtual void AsyncSetKeyValue(const char * key, const char * value) = 0;
 
     /**
      * @brief
@@ -140,7 +140,7 @@ class DLL_EXPORT PersistentStorageDelegate
      * @param[in] value Value to be set
      * @param[in] size Size of the Value
      */
-    virtual CHIP_ERROR SetKeyValue(const char * key, const void * value, uint16_t size) { return CHIP_ERROR_NOT_IMPLEMENTED; }
+    virtual CHIP_ERROR SyncSetKeyValue(const char * key, const void * value, uint16_t size) { return CHIP_ERROR_NOT_IMPLEMENTED; }
 
     /**
      * @brief
@@ -148,7 +148,7 @@ class DLL_EXPORT PersistentStorageDelegate
      *
      * @param[in] key Key to be deleted
      */
-    virtual void DeleteKeyValue(const char * key) = 0;
+    virtual void AsyncDeleteKeyValue(const char * key) = 0;
 };
 
 } // namespace chip
diff --git a/src/transport/AdminPairingTable.cpp b/src/transport/AdminPairingTable.cpp
index 50fefd0afd640d..e3a7de9117f4bc 100644
--- a/src/transport/AdminPairingTable.cpp
+++ b/src/transport/AdminPairingTable.cpp
@@ -37,7 +37,7 @@ CHIP_ERROR AdminPairingInfo::StoreIntoKVS(PersistentStorageDelegate & kvs)
     info.mNodeId = Encoding::LittleEndian::HostSwap64(mNodeId);
     info.mAdmin  = Encoding::LittleEndian::HostSwap16(mAdmin);
 
-    return kvs.SetKeyValue(key, &info, sizeof(info));
+    return kvs.SyncSetKeyValue(key, &info, sizeof(info));
 }
 
 CHIP_ERROR AdminPairingInfo::FetchFromKVS(PersistentStorageDelegate & kvs)
@@ -48,7 +48,7 @@ CHIP_ERROR AdminPairingInfo::FetchFromKVS(PersistentStorageDelegate & kvs)
     StorableAdminPairingInfo info;
 
     uint16_t size = sizeof(info);
-    ReturnErrorOnFailure(kvs.GetKeyValue(key, &info, size));
+    ReturnErrorOnFailure(kvs.SyncGetKeyValue(key, &info, size));
 
     mNodeId    = Encoding::LittleEndian::HostSwap64(info.mNodeId);
     AdminId id = Encoding::LittleEndian::HostSwap16(info.mAdmin);
@@ -62,7 +62,7 @@ CHIP_ERROR AdminPairingInfo::DeleteFromKVS(PersistentStorageDelegate & kvs, Admi
     char key[KeySize()];
     ReturnErrorOnFailure(GenerateKey(id, key, sizeof(key)));
 
-    kvs.DeleteKeyValue(key);
+    kvs.AsyncDeleteKeyValue(key);
     return CHIP_NO_ERROR;
 }
 
diff --git a/src/transport/StorablePeerConnection.cpp b/src/transport/StorablePeerConnection.cpp
index f5ba0a733d7f04..5d5feb8b83f78b 100644
--- a/src/transport/StorablePeerConnection.cpp
+++ b/src/transport/StorablePeerConnection.cpp
@@ -34,7 +34,7 @@ CHIP_ERROR StorablePeerConnection::StoreIntoKVS(PersistentStorageDelegate & kvs)
     char key[KeySize()];
     ReturnErrorOnFailure(GenerateKey(mKeyId, key, sizeof(key)));
 
-    return kvs.SetKeyValue(key, &mSession, sizeof(mSession));
+    return kvs.SyncSetKeyValue(key, &mSession, sizeof(mSession));
 }
 
 CHIP_ERROR StorablePeerConnection::FetchFromKVS(PersistentStorageDelegate & kvs, uint16_t keyId)
@@ -43,7 +43,7 @@ CHIP_ERROR StorablePeerConnection::FetchFromKVS(PersistentStorageDelegate & kvs,
     ReturnErrorOnFailure(GenerateKey(keyId, key, sizeof(key)));
 
     uint16_t size = sizeof(mSession);
-    return kvs.GetKeyValue(key, &mSession, size);
+    return kvs.SyncGetKeyValue(key, &mSession, size);
 }
 
 CHIP_ERROR StorablePeerConnection::DeleteFromKVS(PersistentStorageDelegate & kvs, uint16_t keyId)
@@ -51,7 +51,7 @@ CHIP_ERROR StorablePeerConnection::DeleteFromKVS(PersistentStorageDelegate & kvs
     char key[KeySize()];
     ReturnErrorOnFailure(GenerateKey(keyId, key, sizeof(key)));
 
-    kvs.DeleteKeyValue(key);
+    kvs.AsyncDeleteKeyValue(key);
     return CHIP_NO_ERROR;
 }