diff --git a/.github/.wordlist.txt b/.github/.wordlist.txt
index 1ffec017b94a1a..c4acd491940e9d 100644
--- a/.github/.wordlist.txt
+++ b/.github/.wordlist.txt
@@ -903,6 +903,7 @@ peerNodeId
 peerSessionId
 pem
 percentageLiftValue
+periodicQueryTimeout
 pexpect
 pickString
 PID
diff --git a/examples/ota-requestor-app/efr32/README.md b/examples/ota-requestor-app/efr32/README.md
index 2db645c03fcf9b..a16a357319fb80 100644
--- a/examples/ota-requestor-app/efr32/README.md
+++ b/examples/ota-requestor-app/efr32/README.md
@@ -95,12 +95,13 @@ See `examples/lighting-app/efr32/README.md`
 -   In a terminal start the provider app passing to it the path to the bootable
     image file created in the previous step:
 
+           rm -r /tmp/chip_*
            ./out/debug/chip-ota-provider-app -f chip-efr32-ota-requestor-example.gbl
 
 -   In a separate terminal run the chip-tool commands to provision the Provider:
 
-             rm -r /tmp/chip_*
              ./out/chip-tool pairing onnetwork 1 20202021
+             ./out/chip-tool accesscontrol write acl '[{"fabricIndex": 1, "privilege": 5, "authMode": 2, "subjects": [112233], "targets": null}, {"fabricIndex": 1, "privilege": 3, "authMode": 2, "subjects": null, "targets": null}]' 1 0
 
 -   If the Requestor had been previously commissioned hold Button 0 for six
     seconds to factory-reset the device.
diff --git a/examples/ota-requestor-app/linux/README.md b/examples/ota-requestor-app/linux/README.md
index e99594e23e7025..88b1ae729d5d3f 100644
--- a/examples/ota-requestor-app/linux/README.md
+++ b/examples/ota-requestor-app/linux/README.md
@@ -17,11 +17,11 @@ scripts/examples/gn_build_example.sh examples/ota-requestor-app/linux out/debug
 In addition to the general options available to all Linux applications, the
 following command line options are available for the OTA Requestor application.
 
-| Directory                         | Description                                                                                                                                                                                                                                          |
-| --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| -q/--delayQuery <Time in seconds> | From boot up, the amount of time to wait before triggering the QueryImage command. If none or zero is supplied, QueryImage will not be triggered automatically. At least one provider location must be written to the DefaultOTAProviders attribute. |
-| -c/--requestorCanConsent          | If supplied, the RequestorCanConsent field of the QueryImage command is set to true. Otherwise, the value is determined by the driver.                                                                                                               |
-| -f/--otaDownloadPath <file path>  | If supplied, the OTA image is downloaded to the given fully-qualified file-path. Otherwise, the value defaults to /tmp/test.bin.                                                                                                                     |
+| Directory                                   | Description                                                                                                                                 |
+| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| -p/--periodicQueryTimeout <Time in seconds> | Periodic timeout for querying providers in the default OTA provider list. If none or zero is supplied the timeout is set to every 24 hours. |
+| -c/--requestorCanConsent                    | If supplied, the RequestorCanConsent field of the QueryImage command is set to true. Otherwise, the value is determined by the driver.      |
+| -f/--otaDownloadPath <file path>            | If supplied, the OTA image is downloaded to the given fully-qualified file-path. Otherwise, the value defaults to /tmp/test.bin.            |
 
 ## Software Image Header
 
@@ -87,7 +87,8 @@ Follow instructions
 #### Run the OTA Requestor application:
 
 ```
-out/chip-ota-requestor-app --discriminator ${REQUESTOR_LONG_DISCRIMINATOR} --secured-device-port ${REQUESTOR_UDP_PORT} --KVS ${KVS_STORE_LOCATION} --delayQuery ${TIME_IN_SECONDS} --otaDownloadPath ${OTA_FILE_PATH}
+out/chip-ota-requestor-app --discriminator ${REQUESTOR_LONG_DISCRIMINATOR} --secured-device-port ${REQUESTOR_UDP_PORT} --KVS ${KVS_STORE_LOCATION} --periodicQueryTimeout ${TIME_IN_SECONDS}
+
 ```
 
 -   `${REQUESTOR_LONG_DISCRIMINATOR}` is the long discriminator specified for
@@ -100,10 +101,9 @@ out/chip-ota-requestor-app --discriminator ${REQUESTOR_LONG_DISCRIMINATOR} --sec
 -   `${KVS_STORE_LOCATION}` is a location where the KVS items will be stored. If
     none is supplied, the default is /tmp/chip_kvs. This must be different from
     the value used by the OTA Provider application.
--   `${TIME_IN_SECONDS}` is the amount of time to wait before triggering the
-    QueryImage command specified by the DefaultOTAProviders attribute
--   `${OTA_FILE_PATH}` is the fully-qualified path for the OTA file download
-    location
+-   `${TIME_IN_SECONDS}` is the periodic timeout for querying providers in the
+    default OTA provider list. If none or zero is supplied the timeout is set to
+    every 24 hours.
 
 #### Commission the OTA Requestor application
 
@@ -215,7 +215,7 @@ scripts/examples/gn_build_example.sh examples/ota-requestor-app/linux/ out chip_
 **Run the OTA Requestor application**
 
 ```
-out/chip-ota-requestor-app --discriminator 18 --secured-device-port 5560 --KVS /tmp/chip_kvs_requestor --delayQuery 30 --otaDownloadPath /tmp/test.bin
+out/chip-ota-requestor-app --discriminator 18 --secured-device-port 5560 --KVS /tmp/chip_kvs_requestor --periodicQueryTimeout 60 --otaDownloadPath /tmp/test.bin
 ```
 
 #### In terminal 3:
@@ -234,14 +234,11 @@ out/chip-tool pairing onnetwork-long 0x1234567890 20202021 18
 
 **Write to the DefaultOTAProviders attribute**
 
-Note that this must be done within 30 seconds (as specified by the
-`--delayQuery 30`) from when the OTA Requestor application was launched
-
 ```
 out/chip-tool otasoftwareupdaterequestor write default-ota-providers '[{"fabricIndex": 1, "providerNodeID": 3735928559, "endpoint": 0}]' 0x0000001234567890 0
 ```
 
-After 30 seconds from when the OTA Requestor application has launched, the OTA
+Every 60 seconds from when the OTA Requestor application has launched, the OTA
 Requestor application with node ID 0x1234567890 will send a QueryImage command
 to the OTA Provider with node ID 0xDEADBEEF, as specified in the
 `DefaultOTAProviders` attribute.
diff --git a/examples/ota-requestor-app/linux/main.cpp b/examples/ota-requestor-app/linux/main.cpp
index 4472d021a3a791..08957422a2a15f 100644
--- a/examples/ota-requestor-app/linux/main.cpp
+++ b/examples/ota-requestor-app/linux/main.cpp
@@ -52,29 +52,27 @@ BDXDownloader gDownloader;
 OTAImageProcessorImpl gImageProcessor;
 
 bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue);
-void OnStartDelayTimerHandler(Layer * systemLayer, void * appState);
 
-constexpr uint16_t kOptionDelayQuery          = 'q';
-constexpr uint16_t kOptionRequestorCanConsent = 'c';
-constexpr uint16_t kOptionOtaDownloadPath     = 'f';
-constexpr size_t kMaxFilePathSize             = 256;
+constexpr uint16_t kOptionPeriodicQueryTimeout = 'p';
+constexpr uint16_t kOptionRequestorCanConsent  = 'c';
+constexpr uint16_t kOptionOtaDownloadPath      = 'f';
+constexpr size_t kMaxFilePathSize              = 256;
 
-uint16_t delayQueryTimeInSec = 0;
+uint32_t gPeriodicQueryTimeoutSec = (24 * 60 * 60);
 chip::Optional<bool> gRequestorCanConsent;
 static char gOtaDownloadPath[kMaxFilePathSize] = "/tmp/test.bin";
 
 OptionDef cmdLineOptionsDef[] = {
-    { "delayQuery", chip::ArgParser::kArgumentRequired, kOptionDelayQuery },
+    { "periodicQueryTimeout", chip::ArgParser::kArgumentRequired, kOptionPeriodicQueryTimeout },
     { "requestorCanConsent", chip::ArgParser::kNoArgument, kOptionRequestorCanConsent },
     { "otaDownloadPath", chip::ArgParser::kArgumentRequired, kOptionOtaDownloadPath },
     {},
 };
 
 OptionSet cmdLineOptions = { HandleOptions, cmdLineOptionsDef, "PROGRAM OPTIONS",
-                             "  -q/--delayQuery <Time in seconds>\n"
-                             "        From boot up, the amount of time to wait before triggering the QueryImage\n"
-                             "        command. If none or zero is supplied, QueryImage will not be triggered automatically. At "
-                             "least one provider location must be written to the DefaultOTAProviders attribute.\n"
+                             "  -p/--periodicQueryTimeout <Time in seconds>\n"
+                             "        Periodic timeout for querying providers in the default OTA provider list\n"
+                             "        If none or zero is supplied the timeout is set to every 24 hours. \n"
                              "  -c/--requestorCanConsent\n"
                              "        If supplied, the RequestorCanConsent field of the QueryImage command is set to true.\n"
                              "        Otherwise, the value is determined by the driver.\n "
@@ -91,6 +89,7 @@ static void InitOTARequestor(void)
 
     gRequestorCore.Init(&(chip::Server::GetInstance()), &gRequestorUser, &gDownloader);
     gRequestorUser.Init(&gRequestorCore, &gImageProcessor);
+    gRequestorUser.SetPeriodicQueryTimeout(gPeriodicQueryTimeoutSec);
 
     // WARNING: this is probably not realistic to know such details of the image or to even have an OTADownloader instantiated at
     // the beginning of program execution. We're using hardcoded values here for now since this is a reference application.
@@ -109,8 +108,8 @@ bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier,
 
     switch (aIdentifier)
     {
-    case kOptionDelayQuery:
-        delayQueryTimeInSec = static_cast<uint16_t>(strtol(aValue, NULL, 0));
+    case kOptionPeriodicQueryTimeout:
+        gPeriodicQueryTimeoutSec = static_cast<uint32_t>(strtoul(aValue, NULL, 0));
         break;
     case kOptionRequestorCanConsent:
         gRequestorCanConsent.SetValue(true);
@@ -138,13 +137,6 @@ void ApplicationInit()
 
     // Initialize all OTA download components
     InitOTARequestor();
-
-    // If a delay is provided, after the timer expires, QueryImage from default OTA provider
-    if (delayQueryTimeInSec > 0)
-    {
-        chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Milliseconds32(delayQueryTimeInSec * 1000),
-                                                    OnStartDelayTimerHandler, nullptr);
-    }
 }
 
 int main(int argc, char * argv[])
@@ -153,9 +145,3 @@ int main(int argc, char * argv[])
     ChipLinuxAppMainLoop();
     return 0;
 }
-
-// Test mode operation
-void OnStartDelayTimerHandler(Layer * systemLayer, void * appState)
-{
-    static_cast<OTARequestor *>(GetRequestorInstance())->TriggerImmediateQuery();
-}
diff --git a/src/app/clusters/ota-requestor/OTARequestor.cpp b/src/app/clusters/ota-requestor/OTARequestor.cpp
index 134e08aa814a48..e66052813d5363 100644
--- a/src/app/clusters/ota-requestor/OTARequestor.cpp
+++ b/src/app/clusters/ota-requestor/OTARequestor.cpp
@@ -44,8 +44,6 @@ using bdx::TransferSession;
 // Global instance of the OTARequestorInterface.
 OTARequestorInterface * globalOTARequestorInstance = nullptr;
 
-constexpr uint32_t kImmediateStartDelayMs = 1; // Start the timer with this value when starting OTA "immediately"
-
 static void LogQueryImageResponse(const QueryImageResponse::DecodableType & response)
 {
     ChipLogDetail(SoftwareUpdate, "QueryImageResponse:");
@@ -90,12 +88,6 @@ static void LogApplyUpdateResponse(const ApplyUpdateResponse::DecodableType & re
     ChipLogDetail(SoftwareUpdate, "  delayedActionTime: %" PRIu32 " seconds", response.delayedActionTime);
 }
 
-void StartDelayTimerHandler(System::Layer * systemLayer, void * appState)
-{
-    VerifyOrReturn(appState != nullptr);
-    static_cast<OTARequestor *>(appState)->ConnectToProvider(OTARequestor::kQueryImage);
-}
-
 void SetRequestorInstance(OTARequestorInterface * instance)
 {
     globalOTARequestorInstance = instance;
@@ -161,6 +153,7 @@ void OTARequestor::OnQueryImageResponse(void * context, const QueryImageResponse
             ChipLogDetail(SoftwareUpdate, "Version %" PRIu32 " is older or same than current version %" PRIu32 ", not updating",
                           update.softwareVersion, requestorCore->mCurrentVersion);
 
+            requestorCore->RecordNewUpdateState(OTAUpdateStateEnum::kIdle, OTAChangeReasonEnum::kSuccess);
             requestorCore->mOtaRequestorDriver->UpdateNotFound(UpdateNotFoundReason::UpToDate,
                                                                System::Clock::Seconds32(response.delayedActionTime.ValueOr(0)));
         }
@@ -168,14 +161,14 @@ void OTARequestor::OnQueryImageResponse(void * context, const QueryImageResponse
         break;
     }
     case OTAQueryStatus::kBusy:
+        requestorCore->RecordNewUpdateState(OTAUpdateStateEnum::kDelayedOnQuery, OTAChangeReasonEnum::kDelayByProvider);
         requestorCore->mOtaRequestorDriver->UpdateNotFound(UpdateNotFoundReason::Busy,
                                                            System::Clock::Seconds32(response.delayedActionTime.ValueOr(0)));
-        requestorCore->RecordNewUpdateState(OTAUpdateStateEnum::kDelayedOnQuery, OTAChangeReasonEnum::kDelayByProvider);
         break;
     case OTAQueryStatus::kNotAvailable:
+        requestorCore->RecordNewUpdateState(OTAUpdateStateEnum::kIdle, OTAChangeReasonEnum::kSuccess);
         requestorCore->mOtaRequestorDriver->UpdateNotFound(UpdateNotFoundReason::NotAvailable,
                                                            System::Clock::Seconds32(response.delayedActionTime.ValueOr(0)));
-        requestorCore->RecordNewUpdateState(OTAUpdateStateEnum::kIdle, OTAChangeReasonEnum::kSuccess);
         break;
     default:
         requestorCore->RecordErrorUpdateState(UpdateFailureState::kQuerying, CHIP_ERROR_BAD_REQUEST);
@@ -205,12 +198,12 @@ void OTARequestor::OnApplyUpdateResponse(void * context, const ApplyUpdateRespon
         requestorCore->mOtaRequestorDriver->UpdateConfirmed(System::Clock::Seconds32(response.delayedActionTime));
         break;
     case OTAApplyUpdateAction::kAwaitNextAction:
-        requestorCore->mOtaRequestorDriver->UpdateSuspended(System::Clock::Seconds32(response.delayedActionTime));
         requestorCore->RecordNewUpdateState(OTAUpdateStateEnum::kDelayedOnApply, OTAChangeReasonEnum::kDelayByProvider);
+        requestorCore->mOtaRequestorDriver->UpdateSuspended(System::Clock::Seconds32(response.delayedActionTime));
         break;
     case OTAApplyUpdateAction::kDiscontinue:
-        requestorCore->mOtaRequestorDriver->UpdateDiscontinued();
         requestorCore->RecordNewUpdateState(OTAUpdateStateEnum::kIdle, OTAChangeReasonEnum::kSuccess);
+        requestorCore->mOtaRequestorDriver->UpdateDiscontinued();
         break;
     }
 }
@@ -241,6 +234,8 @@ EmberAfStatus OTARequestor::HandleAnnounceOTAProvider(app::CommandHandler * comm
 {
     auto & announcementReason = commandData.announcementReason;
 
+    ChipLogProgress(SoftwareUpdate, "OTA Requestor received AnnounceOTAProvider");
+
     if (commandObj == nullptr || commandObj->GetExchangeContext() == nullptr)
     {
         ChipLogError(SoftwareUpdate, "Cannot access ExchangeContext for FabricIndex");
@@ -251,9 +246,6 @@ EmberAfStatus OTARequestor::HandleAnnounceOTAProvider(app::CommandHandler * comm
                                                 .providerNodeID = commandData.providerNodeId,
                                                 .endpoint       = commandData.endpoint };
 
-    SetCurrentProviderLocation(providerLocation);
-
-    ChipLogProgress(SoftwareUpdate, "OTA Requestor received AnnounceOTAProvider");
     ChipLogDetail(SoftwareUpdate, "  FabricIndex: %u", providerLocation.fabricIndex);
     ChipLogDetail(SoftwareUpdate, "  ProviderNodeID: 0x" ChipLogFormatX64, ChipLogValueX64(providerLocation.providerNodeID));
     ChipLogDetail(SoftwareUpdate, "  VendorID: 0x%" PRIx16, commandData.vendorId);
@@ -264,36 +256,35 @@ EmberAfStatus OTARequestor::HandleAnnounceOTAProvider(app::CommandHandler * comm
     }
     ChipLogDetail(SoftwareUpdate, "  Endpoint: %" PRIu16, providerLocation.endpoint);
 
-    // If reason is URGENT_UPDATE_AVAILABLE, we start OTA immediately. Otherwise, respect the timer value set in mOtaStartDelayMs.
-    // This is done to exemplify what a real-world OTA Requestor might do while also being configurable enough to use as a test app.
-    uint32_t msToStart = 0;
-    switch (announcementReason)
-    {
-    case OTAAnnouncementReason::kSimpleAnnouncement:
-    case OTAAnnouncementReason::kUpdateAvailable:
-        msToStart = mOtaStartDelayMs;
-        break;
-    case OTAAnnouncementReason::kUrgentUpdateAvailable:
-        msToStart = kImmediateStartDelayMs;
-        break;
-    default:
-        ChipLogError(SoftwareUpdate, "Unexpected announcementReason: %u", static_cast<uint8_t>(announcementReason));
-        return EMBER_ZCL_STATUS_FAILURE;
-    }
-
-    DeviceLayer::SystemLayer().StartTimer(System::Clock::Milliseconds32(msToStart), StartDelayTimerHandler, this);
+    mOtaRequestorDriver->ProcessAnnounceOTAProviders(providerLocation, announcementReason);
 
     return EMBER_ZCL_STATUS_SUCCESS;
 }
 
 void OTARequestor::ConnectToProvider(OnConnectedAction onConnectedAction)
 {
-    VerifyOrReturn(mOtaRequestorDriver != nullptr, ChipLogError(SoftwareUpdate, "OTA requestor driver not set"));
-    VerifyOrReturn(mServer != nullptr, ChipLogError(SoftwareUpdate, "Server not set"));
-    VerifyOrReturn(mProviderLocation.HasValue(), ChipLogError(SoftwareUpdate, "Provider location not set"));
+    if (mServer == nullptr)
+    {
+        ChipLogError(SoftwareUpdate, "Server not set");
+        RecordErrorUpdateState(UpdateFailureState::kUnknown, CHIP_ERROR_INCORRECT_STATE);
+        return;
+    }
+
+    if (!mProviderLocation.HasValue())
+    {
+        ChipLogError(SoftwareUpdate, "Provider location not set");
+        RecordErrorUpdateState(UpdateFailureState::kUnknown, CHIP_ERROR_INCORRECT_STATE);
+        return;
+    }
 
     FabricInfo * fabricInfo = mServer->GetFabricTable().FindFabricWithIndex(mProviderLocation.Value().fabricIndex);
-    VerifyOrReturn(fabricInfo != nullptr, ChipLogError(SoftwareUpdate, "Cannot find fabric"));
+
+    if (fabricInfo == nullptr)
+    {
+        ChipLogError(SoftwareUpdate, "Cannot find fabric");
+        RecordErrorUpdateState(UpdateFailureState::kUnknown, CHIP_ERROR_INCORRECT_STATE);
+        return;
+    }
 
     // Set the action to take once connection is successfully established
     mOnConnectedAction = onConnectedAction;
@@ -303,20 +294,64 @@ void OTARequestor::ConnectToProvider(OnConnectedAction onConnectedAction)
     CHIP_ERROR err =
         mCASESessionManager->FindOrEstablishSession(fabricInfo->GetPeerIdForNode(mProviderLocation.Value().providerNodeID),
                                                     &mOnConnectedCallback, &mOnConnectionFailureCallback);
-    VerifyOrReturn(err == CHIP_NO_ERROR,
-                   ChipLogError(SoftwareUpdate, "Cannot establish connection to provider: %" CHIP_ERROR_FORMAT, err.Format()));
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(SoftwareUpdate, "Cannot establish connection to provider: %" CHIP_ERROR_FORMAT, err.Format());
+        RecordErrorUpdateState(UpdateFailureState::kUnknown, CHIP_ERROR_INCORRECT_STATE);
+        return;
+    }
 }
 
-// Application directs the Requestor to cancel image update in progress. All the Requestor state is
+OTARequestorInterface::UpdateState OTARequestor::GetCurrentUpdateState()
+{
+    UpdateState state = kStateUnknown;
+
+    switch (mCurrentUpdateState)
+    {
+    case OTAUpdateStateEnum::kUnknown:
+        state = kStateUnknown;
+        break;
+    case OTAUpdateStateEnum::kIdle:
+        state = kStateIdle;
+        break;
+    case OTAUpdateStateEnum::kQuerying:
+        state = kStateQuerying;
+        break;
+    case OTAUpdateStateEnum::kDelayedOnQuery:
+        state = kStateDelayedOnQuery;
+        break;
+    case OTAUpdateStateEnum::kDownloading:
+        state = kStateDownloading;
+        break;
+    case OTAUpdateStateEnum::kApplying:
+        state = kStateApplying;
+        break;
+    case OTAUpdateStateEnum::kDelayedOnApply:
+        state = kStateDelayedOnApply;
+        break;
+    case OTAUpdateStateEnum::kRollingBack:
+        state = kStateRollingBack;
+        break;
+    case OTAUpdateStateEnum::kDelayedOnUserConsent:
+        state = kStateDelayedOnUserConsent;
+        break;
+    default:
+        state = kStateUnknown;
+        break;
+    }
+
+    return state;
+}
+
+// Requestor is directed to cancel image update in progress. All the Requestor state is
 // cleared, UpdateState is reset to Idle
 void OTARequestor::CancelImageUpdate()
 {
     mBdxDownloader->EndDownload(CHIP_ERROR_CONNECTION_ABORTED);
 
-    RecordNewUpdateState(OTAUpdateStateEnum::kIdle, OTAChangeReasonEnum::kUnknown);
-
-    // Notify the platform, it might choose to take additional actions
     mOtaRequestorDriver->UpdateCancelled();
+
+    RecordNewUpdateState(OTAUpdateStateEnum::kIdle, OTAChangeReasonEnum::kUnknown);
 }
 
 CHIP_ERROR OTARequestor::GetUpdateProgress(EndpointId endpointId, app::DataModel::Nullable<uint8_t> & progress)
@@ -351,7 +386,7 @@ void OTARequestor::OnConnected(void * context, OperationalDeviceProxy * devicePr
             return;
         }
 
-        requestorCore->RecordNewUpdateState(OTAUpdateStateEnum::kQuerying, OTAChangeReasonEnum::kSuccess);
+        // The kQuerying state is set in TriggerImmediateQueryInternal(), do not set it here
         break;
     }
     case kStartBDX: {
@@ -421,20 +456,41 @@ void OTARequestor::OnConnectionFailure(void * context, PeerId peerId, CHIP_ERROR
     default:
         break;
     }
+
+    // Give driver a chance to schedule another query
+    requestorCore->mOtaRequestorDriver->UpdateNotFound(UpdateNotFoundReason::ConnectionFailed, chip::System::Clock::Seconds32(0));
 }
 
+// Sends the QueryImage command to the Provider currently set in the OTARequestor
+void OTARequestor::TriggerImmediateQueryInternal()
+{
+    // We are now connecting to a provider for the purpose of sending a QueryImage,
+    // treat this as a move to the Querying state
+    RecordNewUpdateState(OTAUpdateStateEnum::kQuerying, OTAChangeReasonEnum::kSuccess);
+
+    ConnectToProvider(kQueryImage);
+}
+
+// Sends the QueryImage command to the next available Provider
 OTARequestorInterface::OTATriggerResult OTARequestor::TriggerImmediateQuery()
 {
-    if (mProviderLocation.HasValue())
-    {
-        ConnectToProvider(kQueryImage);
-        return kTriggerSuccessful;
-    }
-    else
+    ProviderLocation::Type providerLocation;
+    if (mOtaRequestorDriver->DetermineProviderLocation(providerLocation) != true)
     {
         ChipLogError(SoftwareUpdate, "No OTA Providers available");
         return kNoProviderKnown;
     }
+
+    SetCurrentProviderLocation(providerLocation);
+
+    // We are now querying a provider, leave the kIdle state.
+    // No state matches this one fully but we can't be in kIdle.
+    RecordNewUpdateState(OTAUpdateStateEnum::kQuerying, OTAChangeReasonEnum::kSuccess);
+
+    // Go through the driver as it has additional logic to execute
+    mOtaRequestorDriver->SendQueryImage();
+
+    return kTriggerSuccessful;
 }
 
 void OTARequestor::DownloadUpdate()
@@ -454,7 +510,13 @@ void OTARequestor::NotifyUpdateApplied(uint32_t version)
 
     // Log the VersionApplied event
     uint16_t productId;
-    VerifyOrReturn(DeviceLayer::ConfigurationMgr().GetProductId(productId) == CHIP_NO_ERROR);
+    if (DeviceLayer::ConfigurationMgr().GetProductId(productId) != CHIP_NO_ERROR)
+    {
+        ChipLogError(SoftwareUpdate, "Cannot get Product ID");
+        RecordErrorUpdateState(UpdateFailureState::kUnknown, CHIP_ERROR_INCORRECT_STATE);
+        return;
+    }
+
     OtaRequestorServerOnVersionApplied(version, productId);
 
     ConnectToProvider(kNotifyUpdateApplied);
@@ -492,20 +554,12 @@ CHIP_ERROR OTARequestor::AddDefaultOtaProvider(const ProviderLocation::Type & pr
 
     ReturnErrorOnFailure(mDefaultOtaProviderList.Add(providerLocation));
 
-    // Should be removed when periodic queries is implemented
-    iterator = mDefaultOtaProviderList.Begin();
-    while (iterator.Next())
-    {
-        SetCurrentProviderLocation(iterator.GetValue());
-        break;
-    }
-
     return CHIP_NO_ERROR;
 }
 
 void OTARequestor::OnDownloadStateChanged(OTADownloader::State state, OTAChangeReasonEnum reason)
 {
-    VerifyOrReturn(mOtaRequestorDriver != nullptr);
+    VerifyOrDie(mOtaRequestorDriver != nullptr);
 
     switch (state)
     {
@@ -515,6 +569,7 @@ void OTARequestor::OnDownloadStateChanged(OTADownloader::State state, OTAChangeR
     case OTADownloader::State::kIdle:
         if (reason != OTAChangeReasonEnum::kSuccess)
         {
+            // TODO: Should we call some driver API to give it a chance to reschedule?
             RecordErrorUpdateState(UpdateFailureState::kDownloading, CHIP_ERROR_CONNECTION_ABORTED, reason);
         }
 
@@ -529,30 +584,6 @@ void OTARequestor::OnUpdateProgressChanged(Nullable<uint8_t> percent)
     OtaRequestorServerSetUpdateStateProgress(percent);
 }
 
-bool OTARequestor::SetCurrentProviderLocation(const ProviderLocationType & providerLocation)
-{
-    // Provider location cannot be modified if there is an OTA update in progress
-    if (mCurrentUpdateState != OTAUpdateStateEnum::kIdle)
-    {
-        return false;
-    }
-
-    mProviderLocation.SetValue(providerLocation);
-    return true;
-}
-
-bool OTARequestor::ClearCurrentProviderLocation(void)
-{
-    // Provider location cannot be modified if there is an OTA update in progress
-    if (mCurrentUpdateState != OTAUpdateStateEnum::kIdle)
-    {
-        return false;
-    }
-
-    mProviderLocation.ClearValue();
-    return true;
-}
-
 void OTARequestor::RecordNewUpdateState(OTAUpdateStateEnum newState, OTAChangeReasonEnum reason)
 {
     // Set server UpdateState attribute
@@ -575,13 +606,15 @@ void OTARequestor::RecordNewUpdateState(OTAUpdateStateEnum newState, OTAChangeRe
     }
     OtaRequestorServerOnStateTransition(mCurrentUpdateState, newState, reason, targetSoftwareVersion);
 
-    mCurrentUpdateState = newState;
-
-    // Provider location should not exist if no OTA update in progress
-    if (mCurrentUpdateState == OTAUpdateStateEnum::kIdle)
+    // Inform the driver that the OTARequestor has entered the kIdle state. A driver implementation
+    // may choose to restart the default provider timer in this case
+    if ((newState == OTAUpdateStateEnum::kIdle) && (mCurrentUpdateState != OTAUpdateStateEnum::kIdle))
     {
-        ClearCurrentProviderLocation();
+        // TODO: Make this API a general state change
+        mOtaRequestorDriver->HandleIdleState();
     }
+
+    mCurrentUpdateState = newState;
 }
 
 void OTARequestor::RecordErrorUpdateState(UpdateFailureState failureState, CHIP_ERROR error, OTAChangeReasonEnum reason)
@@ -591,7 +624,7 @@ void OTARequestor::RecordErrorUpdateState(UpdateFailureState failureState, CHIP_
 
     // Log the DownloadError event
     OTAImageProcessorInterface * imageProcessor = mBdxDownloader->GetImageProcessorDelegate();
-    VerifyOrReturn(imageProcessor != nullptr);
+    VerifyOrDie(imageProcessor != nullptr);
     Nullable<uint8_t> progressPercent = imageProcessor->GetPercentComplete();
     Nullable<int64_t> platformCode;
     OtaRequestorServerOnDownloadError(mTargetVersion, imageProcessor->GetBytesDownloaded(), progressPercent, platformCode);
@@ -745,4 +778,18 @@ CHIP_ERROR OTARequestor::SendNotifyUpdateAppliedRequest(OperationalDeviceProxy &
     return cluster.InvokeCommand(args, this, OnNotifyUpdateAppliedResponse, OnNotifyUpdateAppliedFailure);
 }
 
+// Invoked when the device becomes commissioned
+void OTARequestor::OnCommissioningCompleteRequestor(const DeviceLayer::ChipDeviceEvent * event, intptr_t arg)
+{
+    VerifyOrReturn(event->Type == DeviceLayer::DeviceEventType::kCommissioningComplete);
+
+    ChipLogProgress(SoftwareUpdate, "Device commissioned, schedule a default provider query");
+
+    // TODO: Should we also send UpdateApplied here?
+
+    // Schedule a query. At the end of this query/update process the Default Provider timer is started
+    OTARequestorDriver * driver = (reinterpret_cast<OTARequestor *>(arg))->mOtaRequestorDriver;
+    driver->OTACommissioningCallback();
+}
+
 } // namespace chip
diff --git a/src/app/clusters/ota-requestor/OTARequestor.h b/src/app/clusters/ota-requestor/OTARequestor.h
index eeb931c999e880..13de1b351a3494 100644
--- a/src/app/clusters/ota-requestor/OTARequestor.h
+++ b/src/app/clusters/ota-requestor/OTARequestor.h
@@ -37,15 +37,6 @@ namespace chip {
 class OTARequestor : public OTARequestorInterface, public BDXDownloader::StateDelegate
 {
 public:
-    // Various actions to take when OnConnected callback is called
-    enum OnConnectedAction
-    {
-        kQueryImage = 0,
-        kStartBDX,
-        kApplyUpdate,
-        kNotifyUpdateApplied,
-    };
-
     OTARequestor() : mOnConnectedCallback(OnConnected, this), mOnConnectionFailureCallback(OnConnectionFailure, this) {}
 
     //////////// OTARequestorInterface Implementation ///////////////
@@ -53,10 +44,13 @@ class OTARequestor : public OTARequestorInterface, public BDXDownloader::StateDe
         app::CommandHandler * commandObj, const app::ConcreteCommandPath & commandPath,
         const app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::DecodableType & commandData) override;
 
-    // Application directs the Requestor to start the Image Query process
-    // and download the new image if available
+    // Application API to send the QueryImage command and start the image update process with the next available Provider
     OTATriggerResult TriggerImmediateQuery() override;
 
+    // Internal API meant for use by OTARequestorDriver to send the QueryImage command and start the image update process
+    // with the Provider currently set in the OTARequestor
+    void TriggerImmediateQueryInternal() override;
+
     // Initiate download of the new image
     void DownloadUpdate() override;
 
@@ -79,6 +73,14 @@ class OTARequestor : public OTARequestorInterface, public BDXDownloader::StateDe
     // Clear all entries with the specified fabric index in the default OTA provider list
     CHIP_ERROR ClearDefaultOtaProviderList(FabricIndex fabricIndex) override;
 
+    using ProviderLocationType = app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type;
+    void SetCurrentProviderLocation(ProviderLocationType providerLocation) override
+    {
+        mProviderLocation.SetValue(providerLocation);
+    }
+
+    void ClearCurrentProviderLocation() override { mProviderLocation.ClearValue(); }
+
     // Add a default OTA provider to the cached list
     CHIP_ERROR AddDefaultOtaProvider(
         const app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type & providerLocation) override;
@@ -98,7 +100,7 @@ class OTARequestor : public OTARequestorInterface, public BDXDownloader::StateDe
      *   - Set the OTA requestor driver instance used to communicate download progress and errors
      *   - Set the BDX downloader instance used for initiating BDX downloads
      */
-    void Init(Server * server, OTARequestorDriver * driver, BDXDownloader * downloader)
+    CHIP_ERROR Init(Server * server, OTARequestorDriver * driver, BDXDownloader * downloader)
     {
         mServer             = server;
         mCASESessionManager = server->GetCASESessionManager();
@@ -106,45 +108,32 @@ class OTARequestor : public OTARequestorInterface, public BDXDownloader::StateDe
         mBdxDownloader      = downloader;
 
         uint32_t version;
-        ReturnOnFailure(DeviceLayer::ConfigurationMgr().GetSoftwareVersion(version));
+        ReturnErrorOnFailure(DeviceLayer::ConfigurationMgr().GetSoftwareVersion(version));
         mCurrentVersion = version;
 
         OtaRequestorServerSetUpdateState(mCurrentUpdateState);
         app::DataModel::Nullable<uint8_t> percent;
         percent.SetNull();
         OtaRequestorServerSetUpdateStateProgress(percent);
+
+        return chip::DeviceLayer::PlatformMgrImpl().AddEventHandler(OnCommissioningCompleteRequestor,
+                                                                    reinterpret_cast<intptr_t>(this));
     }
 
-    /**
-     * Called to establish a session to mProviderLocation. This must be called from the same externally
-     * synchronized context as any other Matter stack method.
-     *
-     * @param onConnectedAction  The action to take once session to provider has been established
-     */
-    void ConnectToProvider(OnConnectedAction onConnectedAction);
+    // Getter for the value of the UpdateState cached by the object
+    UpdateState GetCurrentUpdateState() override;
 
     /**
      * Called to set optional requestorCanConsent value provided by Requestor.
      */
     void SetRequestorCanConsent(bool requestorCanConsent) { mRequestorCanConsent.SetValue(requestorCanConsent); }
 
-    /**
-     * Set the OTA provider location to use for the next query
-     */
-    bool
-    SetCurrentProviderLocation(const app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type & providerLocation);
-
-    /**
-     * Clear the OTA provider location to indicate no OTA update may be in progress
-     */
-    bool ClearCurrentProviderLocation(void);
-
 private:
     using QueryImageResponseDecodableType  = app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImageResponse::DecodableType;
     using ApplyUpdateResponseDecodableType = app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateResponse::DecodableType;
-    using ProviderLocationType             = app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type;
-    using OTAUpdateStateEnum               = app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum;
-    using OTAChangeReasonEnum              = app::Clusters::OtaSoftwareUpdateRequestor::OTAChangeReasonEnum;
+
+    using OTAUpdateStateEnum  = app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum;
+    using OTAChangeReasonEnum = app::Clusters::OtaSoftwareUpdateRequestor::OTAChangeReasonEnum;
 
     static constexpr size_t kMaxUpdateTokenLen = 32;
 
@@ -237,6 +226,22 @@ class OTARequestor : public OTARequestorInterface, public BDXDownloader::StateDe
      */
     CHIP_ERROR ExtractUpdateDescription(const QueryImageResponseDecodableType & response, UpdateDescription & update) const;
 
+    // Various actions to take when OnConnected callback is called
+    enum OnConnectedAction
+    {
+        kQueryImage = 0,
+        kStartBDX,
+        kApplyUpdate,
+        kNotifyUpdateApplied,
+    };
+
+    /**
+     * Called to establish a session to mProviderLocation.
+     *
+     * @param onConnectedAction  The action to take once session to provider has been established
+     */
+    void ConnectToProvider(OnConnectedAction onConnectedAction);
+
     /**
      * Start download of the software image returned in QueryImageResponse
      */
@@ -278,8 +283,12 @@ class OTARequestor : public OTARequestorInterface, public BDXDownloader::StateDe
     static void OnNotifyUpdateAppliedResponse(void * context, const app::DataModel::NullObjectType & response);
     static void OnNotifyUpdateAppliedFailure(void * context, CHIP_ERROR error);
 
+    /**
+     * Commissioning callback
+     */
+    static void OnCommissioningCompleteRequestor(const DeviceLayer::ChipDeviceEvent * event, intptr_t arg);
+
     OTARequestorDriver * mOtaRequestorDriver  = nullptr;
-    uint32_t mOtaStartDelayMs                 = 0;
     CASESessionManager * mCASESessionManager  = nullptr;
     OnConnectedAction mOnConnectedAction      = kQueryImage;
     Messaging::ExchangeContext * mExchangeCtx = nullptr;
diff --git a/src/include/platform/OTARequestorDriver.h b/src/include/platform/OTARequestorDriver.h
index 3b6c87698e3a61..4c491ab13ad2fe 100644
--- a/src/include/platform/OTARequestorDriver.h
+++ b/src/include/platform/OTARequestorDriver.h
@@ -44,6 +44,8 @@ struct UpdateDescription
 
 enum class UpdateFailureState
 {
+    kUnknown,
+    kIdle,
     kQuerying,
     kDownloading,
     kApplying,
@@ -55,7 +57,8 @@ enum class UpdateNotFoundReason
 {
     Busy,
     NotAvailable,
-    UpToDate
+    UpToDate,
+    ConnectionFailed,
 };
 
 // Interface class to abstract the OTA-related business logic. Each application
@@ -74,6 +77,9 @@ class OTARequestorDriver
     /// Called when an error occurs at any OTA requestor operation
     virtual void HandleError(UpdateFailureState state, CHIP_ERROR error) = 0;
 
+    // Called when the OTA Requestor enters the kIdle update state
+    virtual void HandleIdleState() = 0;
+
     /// Called when the latest query found a software update
     virtual void UpdateAvailable(const UpdateDescription & update, System::Clock::Seconds32 delay) = 0;
 
@@ -94,6 +100,27 @@ class OTARequestorDriver
 
     /// Called when the current software update has been cancelled by the local application
     virtual void UpdateCancelled() = 0;
+
+    /// Inform the driver that the device commissioning has completed
+    virtual void OTACommissioningCallback() = 0;
+
+    using ProviderLocationType = app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type;
+    virtual void
+    /// Driver portion of the logic for processing the AnnounceOTAProviders command
+    ProcessAnnounceOTAProviders(const ProviderLocationType & providerLocation,
+                                app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason announcementReason) = 0;
+
+    /// Direct the driver to trigger the QueryImage command. The driver may choose to execute some internal
+    /// logic and will then call an OTARequestor API to actually send the command. The purpose of this
+    /// function is to allow implementation-specific logic (such as possibly cancelling an ongoing update)
+    /// to be executed before triggering the image update process
+    virtual void SendQueryImage() = 0;
+
+    // Driver picks the OTA Provider that should be used for the next query and update. The Provider is picked according to
+    // the driver's internal logic such as, for example, traversing the default providers list.
+    // Returns true if there is a Provider available for the next query, returns false otherwise.
+    virtual bool
+    DetermineProviderLocation(app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type & providerLocation) = 0;
 };
 
 } // namespace chip
diff --git a/src/include/platform/OTARequestorInterface.h b/src/include/platform/OTARequestorInterface.h
index 5575bb1987f344..17c20ddb84957b 100644
--- a/src/include/platform/OTARequestorInterface.h
+++ b/src/include/platform/OTARequestorInterface.h
@@ -147,7 +147,21 @@ class OTARequestorInterface
     enum OTATriggerResult
     {
         kTriggerSuccessful = 0,
-        kNoProviderKnown   = 1
+        kNoProviderKnown   = 1,
+        kWrongState        = 2
+    };
+
+    enum UpdateState
+    {
+        kStateUnknown,
+        kStateIdle,
+        kStateQuerying,
+        kStateDelayedOnQuery,
+        kStateDownloading,
+        kStateApplying,
+        kStateDelayedOnApply,
+        kStateRollingBack,
+        kStateDelayedOnUserConsent,
     };
 
     // Handler for the AnnounceOTAProvider command
@@ -158,9 +172,13 @@ class OTARequestorInterface
     // Destructor
     virtual ~OTARequestorInterface() = default;
 
-    // Send QueryImage command
+    // Application API to send the QueryImage command and start the image update process with the next available Provider
     virtual OTATriggerResult TriggerImmediateQuery() = 0;
 
+    // Internal API meant for use by OTARequestorDriver to send the QueryImage command and start the image update process
+    // with the Provider currently set in the OTARequestor
+    virtual void TriggerImmediateQueryInternal() = 0;
+
     // Download image
     virtual void DownloadUpdate() = 0;
 
@@ -173,9 +191,11 @@ class OTARequestorInterface
     // Get image update progress in percents unit
     virtual CHIP_ERROR GetUpdateProgress(EndpointId endpointId, chip::app::DataModel::Nullable<uint8_t> & progress) = 0;
 
-    // Get requestor state
+    // Get the value of the UpdateState attribute of the OTA Software Update Requestor Cluster on the given endpoint
     virtual CHIP_ERROR GetState(EndpointId endpointId,
                                 chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum & state) = 0;
+    // Getter for the value of the UpdateState cached by the object
+    virtual UpdateState GetCurrentUpdateState() = 0;
 
     // Application directs the Requestor to cancel image update in progress. All the Requestor state is
     // cleared, UpdateState is reset to Idle
@@ -184,6 +204,14 @@ class OTARequestorInterface
     // Clear all entries with the specified fabric index in the default OTA provider list
     virtual CHIP_ERROR ClearDefaultOtaProviderList(FabricIndex fabricIndex) = 0;
 
+    using ProviderLocationType = app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type;
+
+    // Set the provider location to be used in the next query and OTA update process
+    virtual void SetCurrentProviderLocation(ProviderLocationType providerLocation) = 0;
+
+    // Clear the provider location to indicate that no OTA update may be in progress
+    virtual void ClearCurrentProviderLocation() = 0;
+
     // Add a default OTA provider to the cached list
     virtual CHIP_ERROR
     AddDefaultOtaProvider(const app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type & providerLocation) = 0;
diff --git a/src/platform/GenericOTARequestorDriver.cpp b/src/platform/GenericOTARequestorDriver.cpp
index 7cb269cf0b3c31..293125d5574d12 100644
--- a/src/platform/GenericOTARequestorDriver.cpp
+++ b/src/platform/GenericOTARequestorDriver.cpp
@@ -15,6 +15,20 @@
  *    limitations under the License.
  */
 
+// This file contains an implementation of the OTARequestorDriver interface class.
+// Individual platforms may supply their own implementations of OTARequestorDriver
+// or use this one. There are no requirements or assumptions on the implementation other
+// than adherence to the OTA Image Update Requestor part of the Matter specification; the
+// aspects of the functionality not mandated by the specification are considered implementation choices.
+//
+// This particular implementation of the OTARequestorDriver makes the following choices:
+// - Only a single timer can be active at any given moment
+// - The default provider timer is running if and only if there is no update in progress (the OTARequestor
+//   UpdateState is kIdle)
+// - AnnounceOTAProviders command is ignored if an update is in progress
+// - The provider location passed in AnnounceOTAProviders is used in a single query (possibly retried) and then discarded
+// - Explicitly triggering a query through TriggerImmediateQuery() cancels any in-progress update
+
 #include "GenericOTARequestorDriver.h"
 
 #include <platform/CHIPDeviceLayer.h>
@@ -25,7 +39,11 @@ namespace chip {
 namespace DeviceLayer {
 namespace {
 
+constexpr uint32_t kDelayQueryUponCommissioningSec = 30; // Delay before sending the initial image query after commissioning
+constexpr uint32_t kImmediateStartDelaySec         = 1;  // Delay before sending a query in response to UrgentUpdateAvailable
+
 using namespace app::Clusters::OtaSoftwareUpdateRequestor;
+using namespace app::Clusters::OtaSoftwareUpdateRequestor::Structs;
 
 GenericOTARequestorDriver * ToDriver(void * context)
 {
@@ -46,29 +64,94 @@ uint16_t GenericOTARequestorDriver::GetMaxDownloadBlockSize()
     return 1024;
 }
 
-void GenericOTARequestorDriver::HandleError(UpdateFailureState state, CHIP_ERROR error)
+void StartDelayTimerHandler(System::Layer * systemLayer, void * appState)
+{
+    static_cast<GenericOTARequestorDriver *>(appState)->SendQueryImage();
+}
+
+bool ProviderLocationsEqual(const ProviderLocation::Type & a, const ProviderLocation::Type & b)
+{
+    if ((a.fabricIndex == b.fabricIndex) && (a.providerNodeID == b.providerNodeID) && (a.endpoint == b.endpoint))
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+void GenericOTARequestorDriver::HandleError(UpdateFailureState state, CHIP_ERROR error) {}
+
+void GenericOTARequestorDriver::HandleIdleState()
 {
-    // TODO: Schedule the next QueryImage
+    // Default provider timer runs if and only if the OTARequestor's update state is kIdle.
+    // Must (re)start the timer every time we enter the kIdle state
+    StartDefaultProviderTimer();
 }
 
 void GenericOTARequestorDriver::UpdateAvailable(const UpdateDescription & update, System::Clock::Seconds32 delay)
 {
+    // IMPLEMENTATION CHOICE:
+    // This implementation unconditionally downloads an available update
+
     VerifyOrDie(mRequestor != nullptr);
-    ScheduleDelayedAction(UpdateFailureState::kDownloading, delay,
-                          [](System::Layer *, void * context) { ToDriver(context)->mRequestor->DownloadUpdate(); });
+    ScheduleDelayedAction(
+        delay, [](System::Layer *, void * context) { ToDriver(context)->mRequestor->DownloadUpdate(); }, this);
 }
 
 void GenericOTARequestorDriver::UpdateNotFound(UpdateNotFoundReason reason, System::Clock::Seconds32 delay)
 {
     VerifyOrDie(mRequestor != nullptr);
 
+    ProviderLocation::Type providerLocation;
+    bool willTryAnotherQuery = false;
+
+    switch (reason)
+    {
+    case UpdateNotFoundReason::UpToDate:
+        willTryAnotherQuery = false;
+        break;
+
+    case UpdateNotFoundReason::Busy:
+        willTryAnotherQuery = true;
+        break;
+
+    case UpdateNotFoundReason::ConnectionFailed:
+    case UpdateNotFoundReason::NotAvailable:
+        // IMPLEMENTATION CHOICE:
+        // This implementation schedules a query only if a different provider is available
+        if ((DetermineProviderLocation(providerLocation) != true) || ProviderLocationsEqual(providerLocation, mLastUsedProvider))
+        {
+            willTryAnotherQuery = false;
+        }
+        else
+        {
+            willTryAnotherQuery = true;
+        }
+        mRequestor->SetCurrentProviderLocation(providerLocation);
+        mLastUsedProvider = providerLocation;
+        break;
+
+    default:
+        willTryAnotherQuery = false;
+        break;
+    }
+
     if (delay < kDefaultDelayedActionTime)
     {
         delay = kDefaultDelayedActionTime;
     }
-
-    ScheduleDelayedAction(UpdateFailureState::kQuerying, delay,
-                          [](System::Layer *, void * context) { ToDriver(context)->mRequestor->TriggerImmediateQuery(); });
+    if (willTryAnotherQuery == true)
+    {
+        ChipLogProgress(SoftwareUpdate, "UpdateNotFound, scheduling a retry");
+        ScheduleDelayedAction(delay, StartDelayTimerHandler, this);
+    }
+    else
+    {
+        ChipLogProgress(SoftwareUpdate, "UpdateNotFound, not scheduling further retries");
+        mRequestor->ClearCurrentProviderLocation();
+    }
 }
 
 void GenericOTARequestorDriver::UpdateDownloaded()
@@ -80,8 +163,8 @@ void GenericOTARequestorDriver::UpdateDownloaded()
 void GenericOTARequestorDriver::UpdateConfirmed(System::Clock::Seconds32 delay)
 {
     VerifyOrDie(mImageProcessor != nullptr);
-    ScheduleDelayedAction(UpdateFailureState::kApplying, delay,
-                          [](System::Layer *, void * context) { ToDriver(context)->mImageProcessor->Apply(); });
+    ScheduleDelayedAction(
+        delay, [](System::Layer *, void * context) { ToDriver(context)->mImageProcessor->Apply(); }, this);
 }
 
 void GenericOTARequestorDriver::UpdateSuspended(System::Clock::Seconds32 delay)
@@ -93,30 +176,162 @@ void GenericOTARequestorDriver::UpdateSuspended(System::Clock::Seconds32 delay)
         delay = kDefaultDelayedActionTime;
     }
 
-    ScheduleDelayedAction(UpdateFailureState::kAwaitingNextAction, delay,
-                          [](System::Layer *, void * context) { ToDriver(context)->mRequestor->ApplyUpdate(); });
+    ScheduleDelayedAction(
+        delay, [](System::Layer *, void * context) { ToDriver(context)->mRequestor->ApplyUpdate(); }, this);
 }
 
 void GenericOTARequestorDriver::UpdateDiscontinued()
 {
     VerifyOrDie(mImageProcessor != nullptr);
     mImageProcessor->Abort();
+
+    // Cancel all update timers
+    UpdateCancelled();
+
+    // Restart the periodic default provider timer
+    StartDefaultProviderTimer();
 }
 
+// Cancel all OTA update timers
 void GenericOTARequestorDriver::UpdateCancelled()
 {
-    // Platform might choose to schedule a retry here
+    // Cancel all OTA Update timers started by  OTARequestorDriver regardless of whether thery are running or not
+    CancelDelayedAction([](System::Layer *, void * context) { ToDriver(context)->mRequestor->DownloadUpdate(); }, this);
+    CancelDelayedAction(StartDelayTimerHandler, this);
+    CancelDelayedAction([](System::Layer *, void * context) { ToDriver(context)->mImageProcessor->Apply(); }, this);
+    CancelDelayedAction([](System::Layer *, void * context) { ToDriver(context)->mRequestor->ApplyUpdate(); }, this);
 }
 
-void GenericOTARequestorDriver::ScheduleDelayedAction(UpdateFailureState state, System::Clock::Seconds32 delay,
-                                                      System::TimerCompleteCallback action)
+void GenericOTARequestorDriver::ScheduleDelayedAction(System::Clock::Seconds32 delay, System::TimerCompleteCallback action,
+                                                      void * aAppState)
 {
-    CHIP_ERROR error = SystemLayer().StartTimer(std::chrono::duration_cast<System::Clock::Timeout>(delay), action, this);
+    VerifyOrDie(SystemLayer().StartTimer(std::chrono::duration_cast<System::Clock::Timeout>(delay), action, aAppState) ==
+                CHIP_NO_ERROR);
+}
+
+void GenericOTARequestorDriver::CancelDelayedAction(System::TimerCompleteCallback action, void * aAppState)
+{
+    SystemLayer().CancelTimer(action, aAppState);
+}
 
-    if (error != CHIP_NO_ERROR)
+// Device commissioning has completed, schedule a provider query
+void GenericOTARequestorDriver::OTACommissioningCallback()
+{
+    // Schedule a query. At the end of this query/update process the Default Provider timer is started
+    ScheduleDelayedAction(
+        System::Clock::Seconds32(kDelayQueryUponCommissioningSec),
+        [](System::Layer *, void * context) { static_cast<OTARequestorDriver *>(context)->SendQueryImage(); }, this);
+}
+
+void GenericOTARequestorDriver::ProcessAnnounceOTAProviders(
+    const ProviderLocationType & providerLocation,
+    app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason announcementReason)
+{
+    // If reason is URGENT_UPDATE_AVAILABLE, we start OTA immediately. Otherwise, respect the timer value set in mOtaStartDelaySec.
+    // This is done to exemplify what a real-world OTA Requestor might do while also being configurable enough to use as a test app.
+    uint32_t secToStart = 0;
+    switch (announcementReason)
     {
-        HandleError(state, error);
+    case OTAAnnouncementReason::kSimpleAnnouncement:
+    case OTAAnnouncementReason::kUpdateAvailable:
+        secToStart = mOtaStartDelaySec;
+        break;
+    case OTAAnnouncementReason::kUrgentUpdateAvailable:
+        // TODO: Implement random delay per spec
+        secToStart = kImmediateStartDelaySec;
+        break;
+    default:
+        ChipLogError(SoftwareUpdate, "Unexpected announcementReason: %u", static_cast<uint8_t>(announcementReason));
+        return;
     }
+
+    // IMPLEMENTATION CHOICE:
+    // This implementation of the OTARequestor driver ignores the announcement if an update is in progress,
+    // otherwise it queries the provider passed in the announcement
+
+    if (mRequestor->GetCurrentUpdateState() != OTARequestorInterface::kStateIdle)
+    {
+        ChipLogProgress(SoftwareUpdate, "State is not kIdle, ignoring the AnnounceOTAProviders. State: %d",
+                        (int) mRequestor->GetCurrentUpdateState());
+        return;
+    }
+
+    // Point the OTARequestor to the announced provider
+    mRequestor->SetCurrentProviderLocation(providerLocation);
+    mLastUsedProvider = providerLocation;
+
+    ScheduleDelayedAction(System::Clock::Seconds32(secToStart), StartDelayTimerHandler, this);
+}
+
+void GenericOTARequestorDriver::SendQueryImage()
+{
+
+    // IMPLEMENTATION CHOICE
+    // In this implementation explicitly triggering a query cancels any in-progress update.
+    UpdateCancelled();
+
+    // Default provider timer only runs when there is no ongoing query/update; must stop it now.
+    // TriggerImmediateQueryInternal() will cause the state to change from kIdle
+    StopDefaultProviderTimer();
+
+    DeviceLayer::SystemLayer().ScheduleLambda([this] { mRequestor->TriggerImmediateQueryInternal(); });
+}
+
+void GenericOTARequestorDriver::DefaultProviderTimerHandler(System::Layer * systemLayer, void * appState)
+{
+    ChipLogProgress(SoftwareUpdate, "Default Provider timer handler is invoked");
+
+    // Determine which provider to query next
+    ProviderLocation::Type providerLocation;
+    if (DetermineProviderLocation(providerLocation) != true)
+    {
+        StartDefaultProviderTimer();
+        return;
+    }
+
+    mRequestor->SetCurrentProviderLocation(providerLocation);
+    mLastUsedProvider = providerLocation;
+
+    SendQueryImage();
+}
+
+void GenericOTARequestorDriver::StartDefaultProviderTimer()
+{
+    ChipLogProgress(SoftwareUpdate, "Starting the Default Provider timer, timeout: %u seconds",
+                    (unsigned int) mPeriodicQueryTimeInterval);
+
+    DeviceLayer::SystemLayer().ScheduleLambda([this] { mRequestor->ClearCurrentProviderLocation(); });
+
+    ScheduleDelayedAction(
+        System::Clock::Seconds32(mPeriodicQueryTimeInterval),
+        [](System::Layer *, void * context) {
+            (static_cast<GenericOTARequestorDriver *>(context))->DefaultProviderTimerHandler(nullptr, context);
+        },
+        this);
+}
+
+void GenericOTARequestorDriver::StopDefaultProviderTimer()
+{
+    ChipLogProgress(SoftwareUpdate, "Stopping the Default Provider timer");
+    CancelDelayedAction(
+        [](System::Layer *, void * context) {
+            (static_cast<GenericOTARequestorDriver *>(context))->DefaultProviderTimerHandler(nullptr, context);
+        },
+        this);
+}
+
+// Returns the next available Provider location
+bool GenericOTARequestorDriver::DetermineProviderLocation(ProviderLocation::Type & providerLocation)
+{
+    auto iterator = mRequestor->GetDefaultOTAProviderListIterator();
+    while (iterator.Next())
+    {
+        // For now, just return the first one
+        providerLocation = iterator.GetValue();
+        return true;
+    }
+
+    return false;
 }
 
 } // namespace DeviceLayer
diff --git a/src/platform/GenericOTARequestorDriver.h b/src/platform/GenericOTARequestorDriver.h
index a029325ebd00cb..ef61e26a2c589e 100644
--- a/src/platform/GenericOTARequestorDriver.h
+++ b/src/platform/GenericOTARequestorDriver.h
@@ -31,6 +31,7 @@ namespace DeviceLayer {
 class GenericOTARequestorDriver : public OTARequestorDriver
 {
 public:
+    //// Public API methods
     /**
      * Called to perform some initialization including:
      *   - Set the OTA requestor instance used to direct download progress
@@ -42,10 +43,20 @@ class GenericOTARequestorDriver : public OTARequestorDriver
         mImageProcessor = processor;
     }
 
+    // Set the timeout (in seconds) for querying providers on the default OTA provider list; must be non-zero
+    void SetPeriodicQueryTimeout(uint32_t timeout)
+    {
+        if (timeout != 0)
+        {
+            mPeriodicQueryTimeInterval = timeout;
+        }
+    }
+
+    //// Virtual methods from OTARequestorDriver
     bool CanConsent() override;
     uint16_t GetMaxDownloadBlockSize() override;
-
     void HandleError(UpdateFailureState state, CHIP_ERROR error) override;
+    void HandleIdleState() override;
     void UpdateAvailable(const UpdateDescription & update, System::Clock::Seconds32 delay) override;
     void UpdateNotFound(UpdateNotFoundReason reason, System::Clock::Seconds32 delay) override;
     void UpdateDownloaded() override;
@@ -53,12 +64,29 @@ class GenericOTARequestorDriver : public OTARequestorDriver
     void UpdateSuspended(System::Clock::Seconds32 delay) override;
     void UpdateDiscontinued() override;
     void UpdateCancelled() override;
+    void OTACommissioningCallback() override;
+    void ProcessAnnounceOTAProviders(const ProviderLocationType & providerLocation,
+                                     app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason announcementReason) override;
+    void SendQueryImage() override;
+
+    // Returns the next available Provider location
+    bool DetermineProviderLocation(
+        app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type & providerLocation) override;
 
 protected:
-    void ScheduleDelayedAction(UpdateFailureState state, System::Clock::Seconds32 delay, System::TimerCompleteCallback action);
+    void StartDefaultProviderTimer();
+    void StopDefaultProviderTimer();
+    void DefaultProviderTimerHandler(System::Layer * systemLayer, void * appState);
+    void ScheduleDelayedAction(System::Clock::Seconds32 delay, System::TimerCompleteCallback action, void * aAppState);
+    void CancelDelayedAction(System::TimerCompleteCallback action, void * aAppState);
 
     OTARequestorInterface * mRequestor           = nullptr;
     OTAImageProcessorInterface * mImageProcessor = nullptr;
+    uint32_t mOtaStartDelaySec                   = 0;
+    uint32_t mPeriodicQueryTimeInterval = (24 * 60 * 60); // Timeout for querying providers on the default OTA provider list
+
+    using ProviderLocationType = app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type;
+    ProviderLocationType mLastUsedProvider; // Provider location used for the last query or update
 };
 
 } // namespace DeviceLayer
diff --git a/src/platform/mbed/OTARequestorDriverImpl.cpp b/src/platform/mbed/OTARequestorDriverImpl.cpp
index 4fb6be1577a31f..d304dcdfee5868 100644
--- a/src/platform/mbed/OTARequestorDriverImpl.cpp
+++ b/src/platform/mbed/OTARequestorDriverImpl.cpp
@@ -41,8 +41,8 @@ void OTARequestorDriverImpl::UpdateAvailable(const UpdateDescription & update, S
             return;
         }
     }
-    ScheduleDelayedAction(UpdateFailureState::kDownloading, delay,
-                          [](System::Layer *, void * context) { ToDriver(context)->mRequestor->DownloadUpdate(); });
+    ScheduleDelayedAction(
+        delay, [](System::Layer *, void * context) { ToDriver(context)->mRequestor->DownloadUpdate(); }, this);
 }
 
 void OTARequestorDriverImpl::UpdateDownloaded()