diff --git a/src/CatM1ConnectionHandler.cpp b/src/CatM1ConnectionHandler.cpp
index 16f0db9..3b1531d 100644
--- a/src/CatM1ConnectionHandler.cpp
+++ b/src/CatM1ConnectionHandler.cpp
@@ -22,16 +22,16 @@
  ******************************************************************************/
 
 CatM1ConnectionHandler::CatM1ConnectionHandler()
-: ConnectionHandler(true, NetworkAdapter::CATM1) { }
+: ConnectionHandler(true, NetworkAdapter::CATM1, true) { }
 
 CatM1ConnectionHandler::CatM1ConnectionHandler(
   const char * pin, const char * apn, const char * login, const char * pass,
   RadioAccessTechnologyType rat, uint32_t band, bool const keep_alive)
-: ConnectionHandler{keep_alive, NetworkAdapter::CATM1}
+: ConnectionHandler{keep_alive, NetworkAdapter::CATM1, true}
 {
   _settings.type = NetworkAdapter::CATM1;
   // To keep the backward compatibility, the user can call enableCheckInternetAvailability(false) for disabling the check
-  _check_internet_availability = true;
+  _flags.check_internet_availability = true;
   strncpy(_settings.catm1.pin, pin, sizeof(_settings.catm1.pin)-1);
   strncpy(_settings.catm1.apn, apn, sizeof(_settings.catm1.apn)-1);
   strncpy(_settings.catm1.login, login, sizeof(_settings.catm1.login)-1);
@@ -39,6 +39,8 @@ CatM1ConnectionHandler::CatM1ConnectionHandler(
   _settings.catm1.rat  = static_cast<uint8_t>(rat);
   _settings.catm1.band = band;
   _reset = false;
+
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -90,7 +92,7 @@ NetworkConnectionState CatM1ConnectionHandler::update_handleConnecting()
     return NetworkConnectionState::DISCONNECTED;
   }
 
-  if(!_check_internet_availability){
+  if(!_flags.check_internet_availability){
     return NetworkConnectionState::CONNECTED;
   }
 
@@ -130,7 +132,7 @@ NetworkConnectionState CatM1ConnectionHandler::update_handleDisconnecting()
 NetworkConnectionState CatM1ConnectionHandler::update_handleDisconnected()
 {
   GSM.end();
-  if (_keep_alive)
+  if (_flags.keep_alive)
   {
     return NetworkConnectionState::INIT;
   }
diff --git a/src/CatM1ConnectionHandler.h b/src/CatM1ConnectionHandler.h
index 2311589..ae0c2ca 100644
--- a/src/CatM1ConnectionHandler.h
+++ b/src/CatM1ConnectionHandler.h
@@ -37,18 +37,18 @@ class CatM1ConnectionHandler : public ConnectionHandler
     CatM1ConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, RadioAccessTechnologyType rat = CATM1, uint32_t band = BAND_3 | BAND_20 | BAND_19, bool const keep_alive = true);
 
 
-    virtual unsigned long getTime() override;
-    virtual Client & getClient() override { return _gsm_client; };
-    virtual UDP & getUDP() override { return _gsm_udp; };
+    unsigned long getTime() override;
+    Client & getClient() override { return _gsm_client; };
+    UDP & getUDP() override { return _gsm_udp; };
 
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
 
   private:
diff --git a/src/CellularConnectionHandler.cpp b/src/CellularConnectionHandler.cpp
index b73f586..33ff83b 100644
--- a/src/CellularConnectionHandler.cpp
+++ b/src/CellularConnectionHandler.cpp
@@ -22,10 +22,10 @@
   CTOR/DTOR
  ******************************************************************************/
 CellularConnectionHandler::CellularConnectionHandler()
-: ConnectionHandler(true, NetworkAdapter::CELL) {}
+: ConnectionHandler(true, NetworkAdapter::CELL, true) { }
 
 CellularConnectionHandler::CellularConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive)
-: ConnectionHandler{keep_alive, NetworkAdapter::CELL}
+: ConnectionHandler{keep_alive, NetworkAdapter::CELL, true}
 {
   _settings.type = NetworkAdapter::CELL;
   strncpy(_settings.cell.pin, pin, sizeof(_settings.cell.pin)-1);
@@ -33,6 +33,7 @@ CellularConnectionHandler::CellularConnectionHandler(const char * pin, const cha
   strncpy(_settings.cell.login, login, sizeof(_settings.cell.login)-1);
   strncpy(_settings.cell.pass, pass, sizeof(_settings.cell.pass)-1);
 
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -77,7 +78,7 @@ NetworkConnectionState CellularConnectionHandler::update_handleConnecting()
     return NetworkConnectionState::INIT;
   }
 
-  if (!_check_internet_availability) {
+  if (!_flags.check_internet_availability) {
     return NetworkConnectionState::CONNECTED;
   }
 
@@ -105,7 +106,7 @@ NetworkConnectionState CellularConnectionHandler::update_handleDisconnecting()
 
 NetworkConnectionState CellularConnectionHandler::update_handleDisconnected()
 {
-  if (_keep_alive) {
+  if (_flags.keep_alive) {
     return NetworkConnectionState::INIT;
   }
   return NetworkConnectionState::CLOSED;
diff --git a/src/CellularConnectionHandler.h b/src/CellularConnectionHandler.h
index 7a5f00b..15fa28b 100644
--- a/src/CellularConnectionHandler.h
+++ b/src/CellularConnectionHandler.h
@@ -37,18 +37,18 @@ class CellularConnectionHandler : public ConnectionHandler
     CellularConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive = true);
 
 
-    virtual unsigned long getTime() override;
-    virtual Client & getClient() override { return _gsm_client; };
-    virtual UDP & getUDP() override;
+    unsigned long getTime() override;
+    Client & getClient() override { return _gsm_client; };
+    UDP & getUDP() override;
 
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
 
   private:
diff --git a/src/ConnectionHandlerDefinitions.h b/src/ConnectionHandlerDefinitions.h
index 969ecd1..53056db 100644
--- a/src/ConnectionHandlerDefinitions.h
+++ b/src/ConnectionHandlerDefinitions.h
@@ -136,18 +136,41 @@
   #define NETWORK_CONNECTED WL_CONNECTED
 #endif
 
+#if defined(__AVR__)
+#ifndef DEBUG_ERROR
+#  define DEBUG_ERROR(fmt, ...) (void)0
+#endif
+
+#ifndef DEBUG_WARNING
+#  define DEBUG_WARNING(fmt, ...) (void)0
+#endif
+
+#ifndef DEBUG_INFO
+#  define DEBUG_INFO(fmt, ...) (void)0
+#endif
+
+#ifndef DEBUG_DEBUG
+#  define DEBUG_DEBUG(fmt, ...) (void)0
+#endif
+
+#ifndef DEBUG_VERBOSE
+#  define DEBUG_VERBOSE(fmt, ...) (void)0
+#endif
+#endif // defined(__AVR__)
+
 /******************************************************************************
   TYPEDEFS
  ******************************************************************************/
 
 enum class NetworkConnectionState : unsigned int {
-  INIT          = 0,
-  CONNECTING    = 1,
-  CONNECTED     = 2,
-  DISCONNECTING = 3,
-  DISCONNECTED  = 4,
-  CLOSED        = 5,
-  ERROR         = 6
+  CHECK         = 0,
+  INIT          = 1,
+  CONNECTING    = 2,
+  CONNECTED     = 3,
+  DISCONNECTING = 4,
+  DISCONNECTED  = 5,
+  CLOSED        = 6,
+  ERROR         = 7
 };
 
 enum class NetworkConnectionEvent {
diff --git a/src/ConnectionHandlerInterface.cpp b/src/ConnectionHandlerInterface.cpp
index e206b85..b8a1a87 100644
--- a/src/ConnectionHandlerInterface.cpp
+++ b/src/ConnectionHandlerInterface.cpp
@@ -18,12 +18,12 @@
   CONSTRUCTOR/DESTRUCTOR
  ******************************************************************************/
 
-ConnectionHandler::ConnectionHandler(bool const keep_alive, NetworkAdapter interface)
-: _keep_alive{keep_alive}
-, _check_internet_availability{false}
+ConnectionHandler::ConnectionHandler(bool const keep_alive, NetworkAdapter interface,
+  bool settings_required)
+: _flags{keep_alive, false, settings_required, false}
 , _interface{interface}
 , _lastConnectionTickTime{millis()}
-, _current_net_connection_state{NetworkConnectionState::INIT}
+, _current_net_connection_state{NetworkConnectionState::CHECK}
 , _timeoutTable(DefaultTimeoutTable)
 {
 
@@ -73,6 +73,7 @@ NetworkConnectionState ConnectionHandler::updateConnectionState() {
    */
   switch (_current_net_connection_state)
   {
+    case NetworkConnectionState::CHECK:         next_net_connection_state = update_handleCheck        (); break;
     case NetworkConnectionState::INIT:          next_net_connection_state = update_handleInit         (); break;
     case NetworkConnectionState::CONNECTING:    next_net_connection_state = update_handleConnecting   (); break;
     case NetworkConnectionState::CONNECTED:     next_net_connection_state = update_handleConnected    (); break;
@@ -109,14 +110,14 @@ void ConnectionHandler::connect()
 {
   if (_current_net_connection_state != NetworkConnectionState::INIT && _current_net_connection_state != NetworkConnectionState::CONNECTING)
   {
-    _keep_alive = true;
+    _flags.keep_alive = true;
     _current_net_connection_state = NetworkConnectionState::INIT;
   }
 }
 
 void ConnectionHandler::disconnect()
 {
-  _keep_alive = false;
+  _flags.keep_alive = false;
   _current_net_connection_state = NetworkConnectionState::DISCONNECTING;
 }
 
@@ -139,3 +140,11 @@ void ConnectionHandler::addDisconnectCallback(OnNetworkEventCallback callback) {
 void ConnectionHandler::addErrorCallback(OnNetworkEventCallback callback) {
   _on_error_event_callback = callback;
 }
+
+NetworkConnectionState ConnectionHandler::update_handleCheck() {
+  if(_flags.settings_required && !_flags.settings_provided) {
+    return NetworkConnectionState::CHECK;
+  } else {
+    return NetworkConnectionState::INIT;
+  }
+}
diff --git a/src/ConnectionHandlerInterface.h b/src/ConnectionHandlerInterface.h
index cfdebd3..88eaf5c 100644
--- a/src/ConnectionHandlerInterface.h
+++ b/src/ConnectionHandlerInterface.h
@@ -23,6 +23,7 @@
 #include <Udp.h>
 #include "ConnectionHandlerDefinitions.h"
 #include "connectionHandlerModels/settings.h"
+#include <stdint.h>
 
 #include <utility>
 
@@ -42,7 +43,8 @@ class GenericConnectionHandler;
 class ConnectionHandler {
   public:
 
-    ConnectionHandler(bool const keep_alive=true, NetworkAdapter interface=NetworkAdapter::NONE);
+    ConnectionHandler(bool const keep_alive=true, NetworkAdapter interface=NetworkAdapter::NONE,
+                      bool settings_required = false);
 
     virtual ~ConnectionHandler() {}
 
@@ -72,7 +74,7 @@ class ConnectionHandler {
     virtual void connect();
     virtual void disconnect();
     void enableCheckInternetAvailability(bool enable) {
-      _check_internet_availability = enable;
+      _flags.check_internet_availability = enable;
     }
 
     virtual void addCallback(NetworkConnectionEvent const event, OnNetworkEventCallback callback);
@@ -88,8 +90,9 @@ class ConnectionHandler {
      * @return true if the update is successful, false otherwise
      */
     virtual bool updateSetting(const models::NetworkSetting& s) {
-      if(_current_net_connection_state == NetworkConnectionState::INIT && s.type == _interface) {
+      if(_current_net_connection_state <= NetworkConnectionState::INIT && s.type == _interface) {
         memcpy(&_settings, &s, sizeof(s));
+        _flags.settings_provided = true;
         return true;
       }
 
@@ -101,7 +104,7 @@ class ConnectionHandler {
       return;
     }
 
-    virtual void setKeepAlive(bool keep_alive=true) { this->_keep_alive = keep_alive; }
+    virtual void setKeepAlive(bool keep_alive=true) { this->_flags.keep_alive = keep_alive; }
 
     inline void updateTimeoutTable(const TimeoutTable& t) { _timeoutTable = t; }
     inline void updateTimeoutTable(TimeoutTable&& t)      { _timeoutTable = std::move(t); }
@@ -113,10 +116,16 @@ class ConnectionHandler {
     virtual NetworkConnectionState updateConnectionState();
     virtual void updateCallback(NetworkConnectionState next_net_connection_state);
 
-    bool _keep_alive;
-    bool _check_internet_availability;
+    struct Flags {
+      bool keep_alive: 1;
+      bool check_internet_availability: 1;
+      bool settings_required: 1;
+      bool settings_provided: 1;
+    } _flags;
+
     NetworkAdapter _interface;
 
+    virtual NetworkConnectionState update_handleCheck        ();
     virtual NetworkConnectionState update_handleInit         () = 0;
     virtual NetworkConnectionState update_handleConnecting   () = 0;
     virtual NetworkConnectionState update_handleConnected    () = 0;
diff --git a/src/EthernetConnectionHandler.cpp b/src/EthernetConnectionHandler.cpp
index 9ef06cf..a10a3c9 100644
--- a/src/EthernetConnectionHandler.cpp
+++ b/src/EthernetConnectionHandler.cpp
@@ -44,6 +44,8 @@ EthernetConnectionHandler::EthernetConnectionHandler(
   memset(_settings.eth.netmask.dword, 0, sizeof(_settings.eth.netmask.dword));
   _settings.eth.timeout = timeout;
   _settings.eth.response_timeout = responseTimeout;
+
+  _flags.settings_provided = true;
 }
 
 EthernetConnectionHandler::EthernetConnectionHandler(
@@ -58,6 +60,8 @@ EthernetConnectionHandler::EthernetConnectionHandler(
   fromIPAddress(netmask, _settings.eth.netmask);
   _settings.eth.timeout = timeout;
   _settings.eth.response_timeout = responseTimeout;
+
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -106,7 +110,7 @@ NetworkConnectionState EthernetConnectionHandler::update_handleConnecting()
     return NetworkConnectionState::INIT;
   }
 
-  if (!_check_internet_availability) {
+  if (!_flags.check_internet_availability) {
     return NetworkConnectionState::CONNECTED;
   }
 
@@ -130,7 +134,7 @@ NetworkConnectionState EthernetConnectionHandler::update_handleConnected()
 {
   if (Ethernet.linkStatus() == LinkOFF) {
     DEBUG_ERROR(F("Ethernet link OFF, connection lost."));
-    if (_keep_alive)
+    if (_flags.keep_alive)
     {
       DEBUG_ERROR(F("Attempting reconnection"));
     }
@@ -147,7 +151,7 @@ NetworkConnectionState EthernetConnectionHandler::update_handleDisconnecting()
 
 NetworkConnectionState EthernetConnectionHandler::update_handleDisconnected()
 {
-  if (_keep_alive)
+  if (_flags.keep_alive)
   {
     return NetworkConnectionState::INIT;
   }
diff --git a/src/EthernetConnectionHandler.h b/src/EthernetConnectionHandler.h
index 82dc893..5a35ec7 100644
--- a/src/EthernetConnectionHandler.h
+++ b/src/EthernetConnectionHandler.h
@@ -54,17 +54,17 @@ class EthernetConnectionHandler : public ConnectionHandler
       unsigned long const responseTimeout = 4000,
       bool const keep_alive = true);
 
-    virtual unsigned long getTime() override { return 0; }
-    virtual Client & getClient() override{ return _eth_client; }
-    virtual UDP & getUDP() override { return _eth_udp; }
+    unsigned long getTime() override { return 0; }
+    Client & getClient() override{ return _eth_client; }
+    UDP & getUDP() override { return _eth_udp; }
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
   private:
 
diff --git a/src/GSMConnectionHandler.cpp b/src/GSMConnectionHandler.cpp
index 82362f8..17c2f71 100644
--- a/src/GSMConnectionHandler.cpp
+++ b/src/GSMConnectionHandler.cpp
@@ -40,18 +40,20 @@ __attribute__((weak)) void mkr_gsm_feed_watchdog()
   CTOR/DTOR
  ******************************************************************************/
 GSMConnectionHandler::GSMConnectionHandler()
-: ConnectionHandler(true, NetworkAdapter::GSM) {}
+: ConnectionHandler(true, NetworkAdapter::GSM, true) { }
 
 GSMConnectionHandler::GSMConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive)
-: ConnectionHandler{keep_alive, NetworkAdapter::GSM}
+: ConnectionHandler(keep_alive, NetworkAdapter::GSM, true)
 {
   _settings.type = NetworkAdapter::GSM;
   // To keep the backward compatibility, the user can call enableCheckInternetAvailability(false) for disabling the check
-  _check_internet_availability = true;
+  _flags.check_internet_availability = true;
   strncpy(_settings.gsm.pin, pin, sizeof(_settings.gsm.pin)-1);
   strncpy(_settings.gsm.apn, apn, sizeof(_settings.gsm.apn)-1);
   strncpy(_settings.gsm.login, login, sizeof(_settings.gsm.login)-1);
   strncpy(_settings.gsm.pass, pass, sizeof(_settings.gsm.pass)-1);
+
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -100,7 +102,7 @@ NetworkConnectionState GSMConnectionHandler::update_handleInit()
 
 NetworkConnectionState GSMConnectionHandler::update_handleConnecting()
 {
-  if(!_check_internet_availability){
+  if(!_flags.check_internet_availability){
     return NetworkConnectionState::CONNECTED;
   }
 
@@ -138,13 +140,13 @@ NetworkConnectionState GSMConnectionHandler::update_handleDisconnecting()
 
 NetworkConnectionState GSMConnectionHandler::update_handleDisconnected()
 {
-  if (_keep_alive)
+  if (_flags.keep_alive)
   {
     return NetworkConnectionState::INIT;
   }
   else
   {
-   return NetworkConnectionState::CLOSED;
+    return NetworkConnectionState::CLOSED;
   }
 }
 
diff --git a/src/GSMConnectionHandler.h b/src/GSMConnectionHandler.h
index 15e5047..f3ae086 100644
--- a/src/GSMConnectionHandler.h
+++ b/src/GSMConnectionHandler.h
@@ -36,18 +36,18 @@ class GSMConnectionHandler : public ConnectionHandler
     GSMConnectionHandler(const char * pin, const char * apn, const char * login, const char * pass, bool const keep_alive = true);
 
 
-    virtual unsigned long getTime() override;
-    virtual Client & getClient() override { return _gsm_client; };
-    virtual UDP & getUDP() override { return _gsm_udp; };
+    unsigned long getTime() override;
+    Client & getClient() override { return _gsm_client; };
+    UDP & getUDP() override { return _gsm_udp; };
 
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
 
   private:
diff --git a/src/GenericConnectionHandler.cpp b/src/GenericConnectionHandler.cpp
index a607681..56feac3 100644
--- a/src/GenericConnectionHandler.cpp
+++ b/src/GenericConnectionHandler.cpp
@@ -17,11 +17,14 @@
 
 static inline ConnectionHandler* instantiate_handler(NetworkAdapter adapter);
 
+GenericConnectionHandler::GenericConnectionHandler(bool const keep_alive)
+: ConnectionHandler(keep_alive, NetworkAdapter::NONE, true), _ch(nullptr) { }
+
 bool GenericConnectionHandler::updateSetting(const models::NetworkSetting& s) {
-    if(_ch != nullptr && _ch->_current_net_connection_state != NetworkConnectionState::INIT) {
+    if(_ch != nullptr && _ch->_current_net_connection_state > NetworkConnectionState::INIT) {
         // If the internal connection handler is already being used and not in INIT phase we cannot update the settings
         return false;
-    } else if(_ch != nullptr && _ch->_current_net_connection_state == NetworkConnectionState::INIT && _interface != s.type) {
+    } else if(_ch != nullptr && _ch->_current_net_connection_state <= NetworkConnectionState::INIT && _interface != s.type) {
         // If the internal connection handler is already being used and in INIT phase and the interface type is being changed
         // -> we need to deallocate the previously allocated handler
 
@@ -36,8 +39,7 @@ bool GenericConnectionHandler::updateSetting(const models::NetworkSetting& s) {
 
     if(_ch != nullptr) {
         _interface = s.type;
-        _ch->setKeepAlive(_keep_alive);
-        _ch->enableCheckInternetAvailability(_check_internet_availability);
+        _ch->_flags = _flags;
         return _ch->updateSetting(s);
     } else {
         _interface = NetworkAdapter::NONE;
@@ -55,27 +57,31 @@ void GenericConnectionHandler::getSetting(models::NetworkSetting& s) {
 }
 
 NetworkConnectionState GenericConnectionHandler::updateConnectionState() {
-    return _ch != nullptr ? _ch->updateConnectionState() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->updateConnectionState() : NetworkConnectionState::CHECK;
+}
+
+NetworkConnectionState GenericConnectionHandler::update_handleCheck() {
+    return _ch != nullptr ? _ch->update_handleCheck() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleInit() {
-    return _ch != nullptr ? _ch->update_handleInit() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleInit() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleConnecting() {
-    return _ch != nullptr ? _ch->update_handleConnecting() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleConnecting() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleConnected() {
-    return _ch != nullptr ? _ch->update_handleConnected() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleConnected() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleDisconnecting() {
-    return _ch != nullptr ? _ch->update_handleDisconnecting() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleDisconnecting() : NetworkConnectionState::CHECK;
 }
 
 NetworkConnectionState GenericConnectionHandler::update_handleDisconnected() {
-    return _ch != nullptr ? _ch->update_handleDisconnected() : NetworkConnectionState::INIT;
+    return _ch != nullptr ? _ch->update_handleDisconnected() : NetworkConnectionState::CHECK;
 }
 
 #if not (defined(BOARD_HAS_LORA) or defined(BOARD_HAS_NOTECARD))
@@ -108,7 +114,7 @@ void GenericConnectionHandler::disconnect() {
 }
 
 void GenericConnectionHandler::setKeepAlive(bool keep_alive) {
-    _keep_alive = keep_alive;
+    _flags.keep_alive = keep_alive;
 
     if(_ch!=nullptr) {
         _ch->setKeepAlive(keep_alive);
diff --git a/src/GenericConnectionHandler.h b/src/GenericConnectionHandler.h
index 81df0f7..f338ad9 100644
--- a/src/GenericConnectionHandler.h
+++ b/src/GenericConnectionHandler.h
@@ -29,7 +29,7 @@ class GenericConnectionHandler : public ConnectionHandler
 {
   public:
 
-    GenericConnectionHandler(bool const keep_alive=true): ConnectionHandler(keep_alive), _ch(nullptr) {}
+    GenericConnectionHandler(bool const keep_alive=true);
 
     #if defined(BOARD_HAS_NOTECARD) || defined(BOARD_HAS_LORA)
       virtual bool available() = 0;
@@ -60,6 +60,7 @@ class GenericConnectionHandler : public ConnectionHandler
 
     NetworkConnectionState updateConnectionState() override;
 
+    NetworkConnectionState update_handleCheck        () override;
     NetworkConnectionState update_handleInit         () override;
     NetworkConnectionState update_handleConnecting   () override;
     NetworkConnectionState update_handleConnected    () override;
diff --git a/src/LoRaConnectionHandler.cpp b/src/LoRaConnectionHandler.cpp
index 19006bc..974a7b4 100644
--- a/src/LoRaConnectionHandler.cpp
+++ b/src/LoRaConnectionHandler.cpp
@@ -38,7 +38,7 @@ typedef enum
   CTOR/DTOR
  ******************************************************************************/
 LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * appkey, _lora_band const band, char const * channelMask, _lora_class const device_class)
-: ConnectionHandler{false, NetworkAdapter::LORA}
+: ConnectionHandler{false, NetworkAdapter::LORA, true}
 {
   _settings.type = NetworkAdapter::LORA;
   strncpy(_settings.lora.appeui, appeui, sizeof(_settings.lora.appeui)-1);
@@ -46,6 +46,8 @@ LoRaConnectionHandler::LoRaConnectionHandler(char const * appeui, char const * a
   _settings.lora.band = band;
   strncpy(_settings.lora.channelMask, channelMask, sizeof(_settings.lora.channelMask)-1);
   _settings.lora.deviceClass = device_class;
+
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -153,7 +155,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected()
   if (network_status != true)
   {
     DEBUG_ERROR(F("Connection to the network lost."));
-    if (_keep_alive)
+    if (_flags.keep_alive)
     {
       DEBUG_ERROR(F("Attempting reconnection"));
     }
@@ -165,7 +167,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleConnected()
 NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting()
 {
   DEBUG_ERROR(F("Connection to the network lost."));
-  if (_keep_alive)
+  if (_flags.keep_alive)
   {
     DEBUG_ERROR(F("Attempting reconnection"));
   }
@@ -174,7 +176,7 @@ NetworkConnectionState LoRaConnectionHandler::update_handleDisconnecting()
 
 NetworkConnectionState LoRaConnectionHandler::update_handleDisconnected()
 {
-  if (_keep_alive)
+  if (_flags.keep_alive)
   {
     return NetworkConnectionState::INIT;
   }
diff --git a/src/LoRaConnectionHandler.h b/src/LoRaConnectionHandler.h
index b56505a..56e2ecf 100644
--- a/src/LoRaConnectionHandler.h
+++ b/src/LoRaConnectionHandler.h
@@ -36,9 +36,9 @@ class LoRaConnectionHandler : public ConnectionHandler
 
     LoRaConnectionHandler(char const * appeui, char const * appkey, _lora_band const band = _lora_band::EU868, char const * channelMask = NULL, _lora_class const device_class = _lora_class::CLASS_A);
 
-    virtual int write(const uint8_t *buf, size_t size) override;
-    virtual int read() override;
-    virtual bool available() override;
+    int write(const uint8_t *buf, size_t size) override;
+    int read() override;
+    bool available() override;
 
     inline String getVersion() { return _modem.version(); }
     inline String getDeviceEUI() { return _modem.deviceEUI(); }
@@ -57,11 +57,11 @@ class LoRaConnectionHandler : public ConnectionHandler
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
 
   private:
diff --git a/src/NBConnectionHandler.cpp b/src/NBConnectionHandler.cpp
index 4da9fd6..1e65361 100644
--- a/src/NBConnectionHandler.cpp
+++ b/src/NBConnectionHandler.cpp
@@ -40,12 +40,12 @@ __attribute__((weak)) void mkr_nb_feed_watchdog()
  ******************************************************************************/
 
 NBConnectionHandler::NBConnectionHandler()
-: ConnectionHandler(true, NetworkAdapter::NB) {}
+: ConnectionHandler(true, NetworkAdapter::NB, true) {}
 
 NBConnectionHandler::NBConnectionHandler(char const * pin, bool const keep_alive)
 : NBConnectionHandler(pin, "", keep_alive)
 {
-
+  _flags.settings_provided = true;
 }
 
 NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, bool const keep_alive)
@@ -55,13 +55,15 @@ NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, boo
 }
 
 NBConnectionHandler::NBConnectionHandler(char const * pin, char const * apn, char const * login, char const * pass, bool const keep_alive)
-: ConnectionHandler{keep_alive, NetworkAdapter::NB}
+: ConnectionHandler{keep_alive, NetworkAdapter::NB, true}
 {
   _settings.type = NetworkAdapter::NB;
   strncpy(_settings.nb.pin, pin, sizeof(_settings.nb.pin)-1);
   strncpy(_settings.nb.apn, apn, sizeof(_settings.nb.apn)-1);
   strncpy(_settings.nb.login, login, sizeof(_settings.nb.login)-1);
   strncpy(_settings.nb.pass, pass, sizeof(_settings.nb.pass)-1);
+
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -138,7 +140,7 @@ NetworkConnectionState NBConnectionHandler::update_handleDisconnecting()
 
 NetworkConnectionState NBConnectionHandler::update_handleDisconnected()
 {
-  if (_keep_alive)
+  if (_flags.keep_alive)
   {
     return NetworkConnectionState::INIT;
   }
diff --git a/src/NBConnectionHandler.h b/src/NBConnectionHandler.h
index a271199..f722fcb 100644
--- a/src/NBConnectionHandler.h
+++ b/src/NBConnectionHandler.h
@@ -38,18 +38,18 @@ class NBConnectionHandler : public ConnectionHandler
     NBConnectionHandler(char const * pin, char const * apn, char const * login, char const * pass, bool const keep_alive = true);
 
 
-    virtual unsigned long getTime() override;
-    virtual Client & getClient() override { return _nb_client; };
-    virtual UDP & getUDP() override { return _nb_udp; };
+    unsigned long getTime() override;
+    Client & getClient() override { return _nb_client; };
+    UDP & getUDP() override { return _nb_udp; };
 
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
 
   private:
diff --git a/src/WiFiConnectionHandler.cpp b/src/WiFiConnectionHandler.cpp
index 54dd61b..7327506 100644
--- a/src/WiFiConnectionHandler.cpp
+++ b/src/WiFiConnectionHandler.cpp
@@ -29,15 +29,15 @@ static int const ESP_WIFI_CONNECTION_TIMEOUT = 3000;
  ******************************************************************************/
 
 WiFiConnectionHandler::WiFiConnectionHandler()
-: ConnectionHandler(true, NetworkAdapter::WIFI) {
-}
+: ConnectionHandler(true, NetworkAdapter::WIFI, true) { }
 
 WiFiConnectionHandler::WiFiConnectionHandler(char const * ssid, char const * pass, bool const keep_alive)
-: ConnectionHandler{keep_alive, NetworkAdapter::WIFI}
+: ConnectionHandler(keep_alive, NetworkAdapter::WIFI, true)
 {
   _settings.type = NetworkAdapter::WIFI;
   strncpy(_settings.wifi.ssid, ssid, sizeof(_settings.wifi.ssid)-1);
   strncpy(_settings.wifi.pwd, pass, sizeof(_settings.wifi.pwd)-1);
+  _flags.settings_provided = true;
 }
 
 /******************************************************************************
@@ -57,41 +57,51 @@ unsigned long WiFiConnectionHandler::getTime()
   PROTECTED MEMBER FUNCTIONS
  ******************************************************************************/
 
-NetworkConnectionState WiFiConnectionHandler::update_handleInit()
+NetworkConnectionState WiFiConnectionHandler::update_handleCheck()
 {
-#if !defined(__AVR__)
-  DEBUG_INFO(F("WiFi.status(): %d"), WiFi.status());
-#endif
-
 #if !defined(ARDUINO_ARCH_ESP8266) && !defined(ARDUINO_ARCH_ESP32)
   if (WiFi.status() == NETWORK_HARDWARE_ERROR)
   {
-#if !defined(__AVR__)
     DEBUG_ERROR(F("WiFi Hardware failure.\nMake sure you are using a WiFi enabled board/shield."));
     DEBUG_ERROR(F("Then reset and retry."));
-#endif
     return NetworkConnectionState::ERROR;
   }
-#if !defined(__AVR__)
   DEBUG_INFO(F("Current WiFi Firmware: %s"), WiFi.firmwareVersion());
-#endif
 
 #if defined(WIFI_FIRMWARE_VERSION_REQUIRED)
   if (String(WiFi.firmwareVersion()) < String(WIFI_FIRMWARE_VERSION_REQUIRED))
   {
-#if !defined(__AVR__)
     DEBUG_ERROR(F("Latest WiFi Firmware: %s"), WIFI_FIRMWARE_VERSION_REQUIRED);
     DEBUG_ERROR(F("Please update to the latest version for best performance."));
-#endif
     delay(5000);
+
+    return NetworkConnectionState::ERROR;
   }
 #endif
 #else
   WiFi.mode(WIFI_STA);
 #endif /* #if !defined(ARDUINO_ARCH_ESP8266) && !defined(ARDUINO_ARCH_ESP32) */
 
+  return ConnectionHandler::update_handleCheck();
+}
+
+NetworkConnectionState WiFiConnectionHandler::update_handleInit()
+{
+  if(!_flags.settings_provided) {
+    return NetworkConnectionState::INIT;
+  }
+
+  DEBUG_INFO(F("WiFi.status(): %d"), WiFi.status());
+
   if (WiFi.status() != WL_CONNECTED)
   {
+    if (strlen(_settings.wifi.ssid) == 0) {
+      DEBUG_WARNING("Provided empty ssid, please provide a valid one");
+      _flags.settings_provided = false;
+
+      return NetworkConnectionState::INIT;
+    }
+
     WiFi.begin(_settings.wifi.ssid, _settings.wifi.pwd);
 #if defined(ARDUINO_ARCH_ESP8266)
     /* Wait connection otherwise board won't connect */
@@ -105,19 +115,15 @@ NetworkConnectionState WiFiConnectionHandler::update_handleInit()
 
   if (WiFi.status() != NETWORK_CONNECTED)
   {
-#if !defined(__AVR__)
     DEBUG_ERROR(F("Connection to \"%s\" failed"), _settings.wifi.ssid);
     DEBUG_INFO(F("Retrying in  \"%d\" milliseconds"), _timeoutTable.timeout.init);
-#endif
     return NetworkConnectionState::INIT;
   }
   else
   {
-#if !defined(__AVR__)
     DEBUG_INFO(F("Connected to \"%s\""), _settings.wifi.ssid);
-#endif
 #if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-  configTime(0, 0, "time.arduino.cc", "pool.ntp.org", "time.nist.gov");
+    configTime(0, 0, "time.arduino.cc", "pool.ntp.org", "time.nist.gov");
 #endif
     return NetworkConnectionState::CONNECTING;
   }
@@ -129,7 +135,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnecting()
     return NetworkConnectionState::INIT;
   }
 
-  if(!_check_internet_availability){
+  if(!_flags.check_internet_availability){
     return NetworkConnectionState::CONNECTED;
   }
 
@@ -152,15 +158,11 @@ NetworkConnectionState WiFiConnectionHandler::update_handleConnected()
 {
   if (WiFi.status() != WL_CONNECTED)
   {
-#if !defined(__AVR__)
     DEBUG_VERBOSE(F("WiFi.status(): %d"), WiFi.status());
     DEBUG_ERROR(F("Connection to \"%s\" lost."), _settings.wifi.ssid);
-#endif
-    if (_keep_alive)
+    if (_flags.keep_alive)
     {
-#if !defined(__AVR__)
       DEBUG_INFO(F("Attempting reconnection"));
-#endif
     }
 
     return NetworkConnectionState::DISCONNECTED;
@@ -179,7 +181,7 @@ NetworkConnectionState WiFiConnectionHandler::update_handleDisconnected()
 #if !defined(ARDUINO_ARCH_ESP8266) && !defined(ARDUINO_ARCH_ESP32)
   WiFi.end();
 #endif /* #if !defined(ARDUINO_ARCH_ESP8266) && !defined(ARDUINO_ARCH_ESP32) */
-  if (_keep_alive)
+  if (_flags.keep_alive)
   {
     return NetworkConnectionState::INIT;
   }
diff --git a/src/WiFiConnectionHandler.h b/src/WiFiConnectionHandler.h
index 1c12c99..68d40f1 100644
--- a/src/WiFiConnectionHandler.h
+++ b/src/WiFiConnectionHandler.h
@@ -59,18 +59,19 @@ class WiFiConnectionHandler : public ConnectionHandler
     WiFiConnectionHandler(char const * ssid, char const * pass, bool const keep_alive = true);
 
 
-    virtual unsigned long getTime() override;
-    virtual Client & getClient() override { return _wifi_client; }
-    virtual UDP & getUDP() override { return _wifi_udp; }
+    unsigned long getTime() override;
+    Client & getClient() override { return _wifi_client; }
+    UDP & getUDP() override { return _wifi_udp; }
 
 
   protected:
 
-    virtual NetworkConnectionState update_handleInit         () override;
-    virtual NetworkConnectionState update_handleConnecting   () override;
-    virtual NetworkConnectionState update_handleConnected    () override;
-    virtual NetworkConnectionState update_handleDisconnecting() override;
-    virtual NetworkConnectionState update_handleDisconnected () override;
+    NetworkConnectionState update_handleCheck        () override;
+    NetworkConnectionState update_handleInit         () override;
+    NetworkConnectionState update_handleConnecting   () override;
+    NetworkConnectionState update_handleConnected    () override;
+    NetworkConnectionState update_handleDisconnecting() override;
+    NetworkConnectionState update_handleDisconnected () override;
 
   private:
     WiFiUDP _wifi_udp;