diff --git a/.github/workflows/compile-examples.yml b/.github/workflows/compile-examples.yml
index 6e4d438..1de2167 100644
--- a/.github/workflows/compile-examples.yml
+++ b/.github/workflows/compile-examples.yml
@@ -26,6 +26,7 @@ jobs:
         - examples/crc32
         - examples/crc16
         - examples/sha256
+        - examples/timedBlink
       SKETCHES_REPORTS_PATH: sketches-reports
 
     strategy:
diff --git a/examples/timedBlink/timedBlink.ino b/examples/timedBlink/timedBlink.ino
new file mode 100644
index 0000000..686e5ed
--- /dev/null
+++ b/examples/timedBlink/timedBlink.ino
@@ -0,0 +1,29 @@
+/*
+    This file is part of the Arduino_CloudUtils library.
+
+    Copyright (c) 2024 Arduino SA
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#include <Arduino_TimedAttempt.h>
+
+#if !defined(LED_BUILTIN) && !defined(ARDUINO_NANO_ESP32)
+static int const LED_BUILTIN = 2;
+#endif
+
+TimedAttempt blink(500, 1000);
+
+void setup() {
+    pinMode(LED_BUILTIN, OUTPUT);
+}
+
+void loop() { 
+  if(blink.isExpired()) {
+    blink.retry();
+    digitalWrite(LED_BUILTIN, blink.getRetryCount() % 2);
+  }
+
+}
diff --git a/extras/test/CMakeLists.txt b/extras/test/CMakeLists.txt
index 2fb0dd0..7877717 100644
--- a/extras/test/CMakeLists.txt
+++ b/extras/test/CMakeLists.txt
@@ -20,6 +20,7 @@ set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 
 include_directories(../../src)
+include_directories(src/arduino)
 
 set(TEST_SRCS
   src/lzss/test_decoder.cpp
@@ -27,6 +28,7 @@ set(TEST_SRCS
   src/crc16/test_crc16.cpp
   src/sha256/test_sha256.cpp
   src/hex/test_hex.cpp
+  src/time/test_TimedAttempt.cpp
 )
 
 set(TEST_DUT_SRCS
@@ -34,6 +36,11 @@ set(TEST_DUT_SRCS
   ../../src/crc/crc16.cpp
   ../../src/sha256/sha2.c
   ../../src/hex/chex.h
+  ../../src/time/TimedAttempt.cpp
+)
+
+set(TEST_STUB_SRCS
+  src/arduino/Arduino.cpp
 )
 
 ##########################################################################
@@ -45,7 +52,7 @@ add_compile_options(-Wno-cast-function-type)
 set(CMAKE_C_FLAGS   ${CMAKE_C_FLAGS}   "--coverage")
 set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "--coverage -Wno-deprecated-copy")
 
-add_executable( ${TEST_TARGET} ${TEST_SRCS} ${TEST_DUT_SRCS} )
+add_executable( ${TEST_TARGET} ${TEST_SRCS} ${TEST_DUT_SRCS} ${TEST_STUB_SRCS})
 target_compile_definitions( ${TEST_TARGET} PUBLIC SOURCE_DIR="${CMAKE_SOURCE_DIR}" )
 
 target_link_libraries( ${TEST_TARGET} Catch2WithMain )
diff --git a/extras/test/src/arduino/Arduino.cpp b/extras/test/src/arduino/Arduino.cpp
new file mode 100644
index 0000000..cf277de
--- /dev/null
+++ b/extras/test/src/arduino/Arduino.cpp
@@ -0,0 +1,21 @@
+/*
+    This file is part of the Arduino_CloudUtils library.
+
+    Copyright (c) 2024 Arduino SA
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#include <Arduino.h>
+
+static unsigned long current_millis = 0;
+
+void set_millis(unsigned long const millis) {
+  current_millis = millis;
+}
+
+unsigned long millis() {
+  return current_millis;
+}
diff --git a/extras/test/src/arduino/Arduino.h b/extras/test/src/arduino/Arduino.h
new file mode 100644
index 0000000..91ef626
--- /dev/null
+++ b/extras/test/src/arduino/Arduino.h
@@ -0,0 +1,18 @@
+/*
+    This file is part of the Arduino_CloudUtils library.
+
+    Copyright (c) 2024 Arduino SA
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+#ifndef min
+  #define min(a,b) ((a)<(b)?(a):(b))
+#endif
+
+void          set_millis(unsigned long const millis);
+unsigned long millis();
diff --git a/extras/test/src/time/test_TimedAttempt.cpp b/extras/test/src/time/test_TimedAttempt.cpp
new file mode 100644
index 0000000..8009492
--- /dev/null
+++ b/extras/test/src/time/test_TimedAttempt.cpp
@@ -0,0 +1,173 @@
+/*
+    This file is part of the Arduino_CloudUtils library.
+
+    Copyright (c) 2024 Arduino SA
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <time/TimedAttempt.h>
+#include <Arduino.h>
+#include <limits.h>
+
+using namespace arduino::time;
+
+SCENARIO("Test broker connection retries") {
+  TimedAttempt _connection_attempt(0,0);
+
+  _connection_attempt.begin(1000UL, 32000UL);
+
+  /* 100000 retries are more or less 37 days without connection */
+  while(_connection_attempt.getRetryCount() < 100000) {
+    _connection_attempt.retry();
+
+   switch(_connection_attempt.getRetryCount()) {
+      case 1:
+      REQUIRE(_connection_attempt.getWaitTime() == 2000);
+      break;
+      case 2:
+      REQUIRE(_connection_attempt.getWaitTime() == 4000);
+      break;
+      case 3:
+      REQUIRE(_connection_attempt.getWaitTime() == 8000);
+      break;
+      case 4:
+      REQUIRE(_connection_attempt.getWaitTime() == 16000);
+      break;
+      default:
+      REQUIRE(_connection_attempt.getWaitTime() == 32000);
+      break;
+    }
+  }
+}
+
+SCENARIO("Test thing id request with no answer from the cloud") {
+  TimedAttempt _attachAttempt(0,0);
+
+  _attachAttempt.begin(2000UL, 32000UL);
+
+  /* 100000 retries are more or less 37 days of requests */
+  while(_attachAttempt.getRetryCount() < 100000) {
+    _attachAttempt.retry();
+
+  switch(_attachAttempt.getRetryCount()) {
+      case 1:
+      REQUIRE(_attachAttempt.getWaitTime() == 4000);
+      break;
+      case 2:
+      REQUIRE(_attachAttempt.getWaitTime() == 8000);
+      break;
+      case 3:
+      REQUIRE(_attachAttempt.getWaitTime() == 16000);
+      break;
+      default:
+      REQUIRE(_attachAttempt.getWaitTime() == 32000);
+      break;
+    }
+  }
+}
+
+SCENARIO("Test thing id request of a detached device") {
+  TimedAttempt _attachAttempt(0,0);
+
+  _attachAttempt.begin(2000UL, 32000UL);
+
+  while(_attachAttempt.getRetryCount() < 100000) {
+    _attachAttempt.retry();
+
+    switch(_attachAttempt.getRetryCount()) {
+      case 1:
+      REQUIRE(_attachAttempt.getWaitTime() == 4000);
+      _attachAttempt.reconfigure(2000UL * 10UL, 32000UL * 40UL);
+      break;
+      case 2:
+      REQUIRE(_attachAttempt.getWaitTime() == 80000);
+      break;
+      case 3:
+      REQUIRE(_attachAttempt.getWaitTime() == 160000);
+      break;
+      case 4:
+      REQUIRE(_attachAttempt.getWaitTime() == 320000);
+      break;
+      case 5:
+      REQUIRE(_attachAttempt.getWaitTime() == 640000);
+      break;
+      default:
+      REQUIRE(_attachAttempt.getWaitTime() == 1280000);
+      break;
+    }
+  }
+}
+
+SCENARIO("Test last value request") {
+  TimedAttempt _syncAttempt(0,0);
+
+  _syncAttempt.begin(30000UL);
+
+  /* 100000 retries are more or less 37 days of requests */
+  while(_syncAttempt.getRetryCount() < 100000) {
+    _syncAttempt.retry();
+
+    switch(_syncAttempt.getRetryCount()) {
+      default:
+      REQUIRE(_syncAttempt.getWaitTime() == 30000);
+      break;
+    }
+  }
+}
+
+SCENARIO("Test isExpired() and isRetry()") {
+  TimedAttempt attempt(0,0);
+
+  attempt.begin(1000UL, 32000UL);
+
+  /* Initial condition */
+  set_millis(0);
+  REQUIRE(attempt.isExpired() == false);
+  REQUIRE(attempt.isRetry() == false);
+
+  /* Normal retry 2000ms */
+  attempt.retry();
+  REQUIRE(attempt.isRetry() == true);
+  set_millis(1000);
+  REQUIRE(attempt.isExpired() == false);
+  set_millis(1999);
+  REQUIRE(attempt.isExpired() == false);
+  set_millis(2000);
+  REQUIRE(attempt.isExpired() == false);
+  set_millis(2001);
+  REQUIRE(attempt.isExpired() == true);
+
+  /* Retry with rollover 4000ms */
+  set_millis(ULONG_MAX - 1999);
+  attempt.retry();
+  REQUIRE(attempt.isRetry() == true);
+  set_millis(0);
+  REQUIRE(attempt.isExpired() == false);
+  set_millis(1999);
+  REQUIRE(attempt.isExpired() == false);
+  set_millis(2000);
+  REQUIRE(attempt.isExpired() == false);
+  set_millis(2001);
+  REQUIRE(attempt.isExpired() == true);
+
+  /* Normal retry 8000ms */
+  set_millis(4000);
+  attempt.retry();
+  REQUIRE(attempt.isRetry() == true);
+  set_millis(4000);
+  REQUIRE(attempt.isExpired() == false);
+  set_millis(11999);
+  REQUIRE(attempt.isExpired() == false);
+  set_millis(12000);
+  REQUIRE(attempt.isExpired() == false);
+  set_millis(12001);
+  REQUIRE(attempt.isExpired() == true);
+
+  attempt.reset();
+  REQUIRE(attempt.isRetry() == false);
+}
diff --git a/src/Arduino_TimedAttempt.h b/src/Arduino_TimedAttempt.h
new file mode 100644
index 0000000..6512dc1
--- /dev/null
+++ b/src/Arduino_TimedAttempt.h
@@ -0,0 +1,14 @@
+/*
+    This file is part of the Arduino_CloudUtils library.
+
+    Copyright (c) 2024 Arduino SA
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+#pragma once
+
+#include "./time/TimedAttempt.h"
+
+using namespace arduino::time;
diff --git a/src/time/TimedAttempt.cpp b/src/time/TimedAttempt.cpp
new file mode 100644
index 0000000..4a0eee8
--- /dev/null
+++ b/src/time/TimedAttempt.cpp
@@ -0,0 +1,78 @@
+/*
+  This file is part of the Arduino_CloudUtils library.
+
+  Copyright (c) 2024 Arduino SA
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+
+#include <Arduino.h>
+#include "TimedAttempt.h"
+
+namespace arduino { namespace time {
+
+    TimedAttempt::TimedAttempt(unsigned long minDelay, unsigned long maxDelay)
+    : _minDelay(minDelay)
+    , _maxDelay(maxDelay) {
+    }
+
+    void TimedAttempt::begin(unsigned long delay) {
+        _retryCount = 0;
+        _retryDelay = 0;
+        _retryTick = 0;
+        _minDelay = delay;
+        _maxDelay = delay;
+    }
+
+    void TimedAttempt::begin(unsigned long minDelay, unsigned long maxDelay) {
+        _retryCount = 0;
+        _retryDelay = 0;
+        _retryTick = 0;
+        _minDelay = minDelay;
+        _maxDelay = maxDelay;
+    }
+
+    unsigned long TimedAttempt::reconfigure(unsigned long minDelay, unsigned long maxDelay) {
+        _minDelay = minDelay;
+        _maxDelay = maxDelay;
+        return reload();
+    }
+
+    unsigned long TimedAttempt::retry() {
+        _retryCount++;
+        return reload();
+    }
+
+    unsigned long TimedAttempt::reload() {
+        unsigned long shift = _retryCount > 31 ? 31 : _retryCount;
+        unsigned long delay = (1UL << shift) * _minDelay;
+        /* delay should always increase */
+        _retryDelay =  (delay > _retryDelay) ? min(delay, _maxDelay): _maxDelay;
+        _retryTick = millis();
+        return _retryDelay;
+    }
+
+    void TimedAttempt::reset() {
+        _retryCount = 0;
+    }
+
+    bool TimedAttempt::isRetry() {
+        return _retryCount > 0;
+    }
+
+    bool TimedAttempt::isExpired() {
+        return millis() - _retryTick > _retryDelay;
+    }
+
+    unsigned int TimedAttempt::getRetryCount() {
+        return _retryCount;
+    }
+
+    unsigned int TimedAttempt::getWaitTime() {
+        return _retryDelay;
+    }
+
+}}  // arduino::time
diff --git a/src/time/TimedAttempt.h b/src/time/TimedAttempt.h
new file mode 100644
index 0000000..523733d
--- /dev/null
+++ b/src/time/TimedAttempt.h
@@ -0,0 +1,100 @@
+/*
+  This file is part of the Arduino_CloudUtils library.
+
+  Copyright (c) 2024 Arduino SA
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+namespace arduino { namespace time {
+
+    /**
+     * The TimedAttempt class manages retry attempts with configurable delays.
+     * It allows setting minimum and maximum delays, and provides methods to
+     * begin, retry, reset, and check the status of attempts.
+     */
+    class TimedAttempt {
+
+    public:
+        /**
+        * Constructor to initialize TimedAttempt with minimum and maximum delay
+        * @param minDelay: minimum delay between attempts
+        * @param maxDelay: maximum delay between attempts
+        */
+        TimedAttempt(unsigned long minDelay, unsigned long maxDelay);
+
+        /**
+        * Begin the attempt with a fixed delay
+        * @param delay: fixed delay between attempts
+        */
+        void begin(unsigned long delay);
+
+        /**
+        * Begin the attempt with a range of delays
+        * @param minDelay: minimum delay between attempts
+        * @param maxDelay: maximum delay between attempts
+        */
+        void begin(unsigned long minDelay, unsigned long maxDelay);
+
+        /**
+        * Reconfigure the attempt with new minimum and maximum delays and reload
+        * @param minDelay: new minimum delay between attempts
+        * @param maxDelay: new maximum delay between attempts
+        * @return the new delay after reconfiguration
+        */
+        unsigned long reconfigure(unsigned long minDelay, unsigned long maxDelay);
+
+        /**
+        * Retry the attempt, incrementing the retry count and reloading the delay
+        * @return the new delay after retry
+        */
+        unsigned long retry();
+
+        /**
+        * Reload the delay based on the retry count and return the new delay
+        * @return the new delay after reload
+        */
+        unsigned long reload();
+
+        /**
+        * Reset the retry count to zero
+        */
+        void reset();
+
+        /**
+        * Check if a retry has been attempted
+        * @return true if a retry has been attempted, false otherwise
+        */
+        bool isRetry();
+
+        /**
+        * Check if the current attempt has expired based on the delay
+        * @return true if the current attempt has expired, false otherwise
+        */
+        bool isExpired();
+
+        /**
+        * Get the current retry count
+        * @return the current retry count
+        */
+        unsigned int getRetryCount();
+
+        /**
+        * Get the current wait time for the next retry
+        * @return the current wait time for the next retry
+        */
+        unsigned int getWaitTime();
+
+    private:
+        unsigned long _minDelay;
+        unsigned long _maxDelay;
+        unsigned long _retryTick;
+        unsigned long _retryDelay;
+        unsigned int _retryCount;
+    };
+
+}}  // arduino::time