diff --git a/dependencies.yaml b/dependencies.yaml
index 805263c14..101f952ec 100644
--- a/dependencies.yaml
+++ b/dependencies.yaml
@@ -1,7 +1,7 @@
 ---
 everest-framework:
   git: https://github.com/EVerest/everest-framework.git
-  git_tag: 61318a6
+  git_tag: 48cad3c
 sigslot:
   git: https://github.com/palacaze/sigslot
   git_tag: v1.2.0
@@ -38,7 +38,7 @@ RISE-V2G:
 # OCPP
 libocpp:
   git: https://github.com/EVerest/libocpp.git
-  git_tag: v0.8.0
+  git_tag: 1b26181
 # Josev
 Josev:
   git: https://github.com/EVerest/ext-switchev-iso15118.git
diff --git a/modules/Auth/include/Connector.hpp b/modules/Auth/include/Connector.hpp
index dbe2d488d..fd82ce6b9 100644
--- a/modules/Auth/include/Connector.hpp
+++ b/modules/Auth/include/Connector.hpp
@@ -4,10 +4,13 @@
 #ifndef _CONNECTOR_HPP_
 #define _CONNECTOR_HPP_
 
+#include <optional>
+
 #include <everest/timer.hpp>
 
 #include <utils/types.hpp>
 
+
 #include <ConnectorStateMachine.hpp>
 #include <generated/types/authorization.hpp>
 
@@ -17,9 +20,9 @@ namespace module {
 struct Identifier {
     std::string id_token; ///< Arbitrary id token string: this has to be printable case insensitive ascii
     types::authorization::TokenType type; ///< Type of the provider of the identifier
-    boost::optional<types::authorization::AuthorizationStatus> authorization_status;
-    boost::optional<std::string> expiry_time; ///< Absolute UTC time point when reservation expires in RFC3339 format
-    boost::optional<std::string> parent_id_token; ///< Parent id token of the id token
+    std::optional<types::authorization::AuthorizationStatus> authorization_status;
+    std::optional<std::string> expiry_time; ///< Absolute UTC time point when reservation expires in RFC3339 format
+    std::optional<std::string> parent_id_token; ///< Parent id token of the id token
 };
 
 struct Connector {
@@ -36,7 +39,7 @@ struct Connector {
     ConnectorStateMachine state_machine;
 
     // identifier is set when transaction is running and none if not
-    boost::optional<Identifier> identifier = boost::none;
+    std::optional<Identifier> identifier = std::nullopt;
 
     bool is_reservable;
     bool reserved;
diff --git a/modules/Auth/include/ReservationHandler.hpp b/modules/Auth/include/ReservationHandler.hpp
index 70cf5d524..bd300ae38 100644
--- a/modules/Auth/include/ReservationHandler.hpp
+++ b/modules/Auth/include/ReservationHandler.hpp
@@ -42,7 +42,7 @@ class ReservationHandler {
      * @return true
      * @return false
      */
-    bool matches_reserved_identifier(int connector, const std::string& id_token, boost::optional<std::string> parent_id_token);
+    bool matches_reserved_identifier(int connector, const std::string& id_token, std::optional<std::string> parent_id_token);
 
     /**
      * @brief Function tries to reserve the given \p connector using the given \p reservation
diff --git a/modules/Auth/lib/AuthHandler.cpp b/modules/Auth/lib/AuthHandler.cpp
index c7c224f24..087d7fdc5 100644
--- a/modules/Auth/lib/AuthHandler.cpp
+++ b/modules/Auth/lib/AuthHandler.cpp
@@ -244,7 +244,7 @@ int AuthHandler::used_for_transaction(const std::vector<int>& connector_ids, con
                 return connector_id;
             }
             // check against parent_id_token
-            else if (identifier.parent_id_token.has_value() && identifier.parent_id_token.get() == token) {
+            else if (identifier.parent_id_token.has_value() && identifier.parent_id_token.value() == token) {
                 return connector_id;
             }
         }
@@ -353,7 +353,7 @@ void AuthHandler::notify_evse(int connector_id, const ProvidedIdToken& provided_
             ->timeout_timer.timeout(
                 [this, evse_index, connector_id]() {
                     EVLOG_info << "Authorization timeout for evse#" << evse_index;
-                    this->connectors.at(connector_id)->connector.identifier = boost::none;
+                    this->connectors.at(connector_id)->connector.identifier.reset();
                     this->withdraw_authorization_callback(evse_index);
                 },
                 std::chrono::seconds(this->connection_timeout));
@@ -418,11 +418,11 @@ void AuthHandler::handle_session_event(const int connector_id, const SessionEven
         break;
     case SessionEventEnum::TransactionFinished:
         this->connectors.at(connector_id)->connector.transaction_active = false;
-        this->connectors.at(connector_id)->connector.identifier = boost::none;
+        this->connectors.at(connector_id)->connector.identifier.reset();
         break;
     case SessionEventEnum::SessionFinished:
         this->connectors.at(connector_id)->connector.is_reservable = true;
-        this->connectors.at(connector_id)->connector.identifier = boost::none;
+        this->connectors.at(connector_id)->connector.identifier.reset();
         this->connectors.at(connector_id)->connector.submit_event(ConnectorEvent::SESSION_FINISHED);
         this->connectors.at(connector_id)->connector.submit_event(ConnectorEvent::ERROR_CLEARED);
         this->connectors.at(connector_id)->timeout_timer.stop();
diff --git a/modules/Auth/lib/ReservationHandler.cpp b/modules/Auth/lib/ReservationHandler.cpp
index e44c9b2e9..683a3ad63 100644
--- a/modules/Auth/lib/ReservationHandler.cpp
+++ b/modules/Auth/lib/ReservationHandler.cpp
@@ -12,7 +12,7 @@ void ReservationHandler::init_connector(int connector_id) {
 }
 
 bool ReservationHandler::matches_reserved_identifier(int connector, const std::string& id_token,
-                                                     boost::optional<std::string> parent_id_token) {
+                                                     std::optional<std::string> parent_id_token) {
     // return true if id tokens match or parent id tokens exists and match
     return this->reservations[connector].id_token == id_token ||
            (parent_id_token && this->reservations[connector].parent_id_token &&
diff --git a/modules/Auth/tests/auth_tests.cpp b/modules/Auth/tests/auth_tests.cpp
index 3f8985b7d..7407a58d4 100644
--- a/modules/Auth/tests/auth_tests.cpp
+++ b/modules/Auth/tests/auth_tests.cpp
@@ -29,8 +29,8 @@ static SessionEvent get_session_started_event(const types::evse_manager::StartSe
 }
 
 static ProvidedIdToken get_provided_token(const std::string& id_token,
-                                          boost::optional<std::vector<int32_t>> connectors = boost::none,
-                                          boost::optional<bool> prevalidated = boost::none) {
+                                          std::optional<std::vector<int32_t>> connectors = std::nullopt,
+                                          std::optional<bool> prevalidated = std::nullopt) {
     ProvidedIdToken provided_token;
     provided_token.id_token = id_token;
     provided_token.type = types::authorization::TokenType::RFID;
diff --git a/modules/EnergyManager/Offer.cpp b/modules/EnergyManager/Offer.cpp
index d695ae41f..b3381b964 100644
--- a/modules/EnergyManager/Offer.cpp
+++ b/modules/EnergyManager/Offer.cpp
@@ -25,25 +25,25 @@ std::ostream& operator<<(std::ostream& out, const Offer& self) {
 }
 
 template <class T> static void apply_one_limit_if_smaller(T& a, const T& b) {
-    if (b.is_initialized()) {
-        if (a.is_initialized()) {
-            if (a.get() > b.get()) {
-                a = b.get();
+    if (b) {
+        if (a) {
+            if (a.value() > b.value()) {
+                a = b.value();
             }
         } else {
-            a = b.get();
+            a = b.value();
         }
     }
 }
 
 template <class T> static void apply_one_limit_if_greater(T& a, const T& b) {
-    if (b.is_initialized()) {
-        if (a.is_initialized()) {
-            if (a.get() < b.get()) {
-                a = b.get();
+    if (b) {
+        if (a) {
+            if (a.value() < b.value()) {
+                a = b.value();
             }
         } else {
-            a = b.get();
+            a = b.value();
         }
     }
 }
diff --git a/modules/EnergyManager/Offer.hpp b/modules/EnergyManager/Offer.hpp
index 504c6ec5c..426fe4af1 100644
--- a/modules/EnergyManager/Offer.hpp
+++ b/modules/EnergyManager/Offer.hpp
@@ -3,9 +3,12 @@
 #ifndef OFFER_HPP
 #define OFFER_HPP
 
+#include <vector>
+#include <optional>
+
 #include "Market.hpp"
 #include <generated/interfaces/energy/Interface.hpp>
-#include <vector>
+
 
 namespace module {
 
@@ -13,7 +16,7 @@ class Offer {
 public:
     Offer(Market& market);
 
-    boost::optional<types::energy::OptimizerTarget> optimizer_target;
+    std::optional<types::energy::OptimizerTarget> optimizer_target;
     ScheduleReq import_offer, export_offer;
 
 private:
diff --git a/modules/EvseManager/EvseManager.cpp b/modules/EvseManager/EvseManager.cpp
index 9ecda1d9e..99d414d3e 100644
--- a/modules/EvseManager/EvseManager.cpp
+++ b/modules/EvseManager/EvseManager.cpp
@@ -163,7 +163,7 @@ void EvseManager::ready() {
 
                     if (config.hack_present_current_offset > 0) {
                         present_values.EVSEPresentCurrent =
-                            present_values.EVSEPresentCurrent.get() + config.hack_present_current_offset;
+                            present_values.EVSEPresentCurrent.value() + config.hack_present_current_offset;
                     }
 
                     if (config.hack_pause_imd_during_precharge && m.voltage_V * m.current_A > 1000) {
@@ -552,10 +552,10 @@ void EvseManager::ready() {
     if (r_powermeter_billing().size() > 0) {
         r_powermeter_billing()[0]->subscribe_powermeter([this](types::powermeter::Powermeter p) {
             // Inform charger about current charging current. This is used for slow OC detection.
-            if (p.current_A.is_initialized() && p.current_A.get().L1.is_initialized() &&
-                p.current_A.get().L2.is_initialized() && p.current_A.get().L3.is_initialized()) {
-                charger->setCurrentDrawnByVehicle(p.current_A.get().L1.get(), p.current_A.get().L2.get(),
-                                                  p.current_A.get().L3.get());
+            if (p.current_A && p.current_A.value().L1 &&
+                p.current_A.value().L2 && p.current_A.value().L3) {
+                charger->setCurrentDrawnByVehicle(p.current_A.value().L1.value(), p.current_A.value().L2.value(),
+                                                  p.current_A.value().L3.value());
             }
 
             // Inform HLC about the power meter data
@@ -570,17 +570,17 @@ void EvseManager::ready() {
             }
 
             // External Nodered interface
-            if (p.phase_seq_error.is_initialized()) {
+            if (p.phase_seq_error) {
                 mqtt.publish(fmt::format("everest_external/nodered/{}/powermeter/phaseSeqError", config.connector_id),
-                             p.phase_seq_error.get());
+                             p.phase_seq_error.value());
             }
 
             mqtt.publish(fmt::format("everest_external/nodered/{}/powermeter/time_stamp", config.connector_id),
                          p.timestamp);
 
-            if (p.power_W.is_initialized()) {
+            if (p.power_W) {
                 mqtt.publish(fmt::format("everest_external/nodered/{}/powermeter/totalKw", config.connector_id),
-                             p.power_W.get().total / 1000., 1);
+                             p.power_W.value().total / 1000., 1);
             }
 
             mqtt.publish(fmt::format("everest_external/nodered/{}/powermeter/totalKWattHr", config.connector_id),
@@ -677,96 +677,96 @@ void EvseManager::ready() {
             auto p = get_latest_powermeter_data_billing();
             Everest::TelemetryMap telemetry_data{{"timestamp", p.timestamp},
                                                  {"type", "power_meter"},
-                                                 {"meter_id", p.meter_id.get_value_or("N/A")},
+                                                 {"meter_id", p.meter_id.value_or("N/A")},
                                                  {"energy_import_total_Wh", p.energy_Wh_import.total}};
 
-            if (p.energy_Wh_import.L1.is_initialized()) {
-                telemetry_data["energy_import_L1_Wh"] = p.energy_Wh_import.L1.get();
+            if (p.energy_Wh_import.L1) {
+                telemetry_data["energy_import_L1_Wh"] = p.energy_Wh_import.L1.value();
             }
-            if (p.energy_Wh_import.L2.is_initialized()) {
-                telemetry_data["energy_import_L2_Wh"] = p.energy_Wh_import.L2.get();
+            if (p.energy_Wh_import.L2) {
+                telemetry_data["energy_import_L2_Wh"] = p.energy_Wh_import.L2.value();
             }
-            if (p.energy_Wh_import.L3.is_initialized()) {
-                telemetry_data["energy_import_L3_Wh"] = p.energy_Wh_import.L3.get();
+            if (p.energy_Wh_import.L3) {
+                telemetry_data["energy_import_L3_Wh"] = p.energy_Wh_import.L3.value();
             }
 
-            if (p.energy_Wh_export.is_initialized()) {
-                telemetry_data["energy_export_total_Wh"] = p.energy_Wh_export.get().total;
+            if (p.energy_Wh_export) {
+                telemetry_data["energy_export_total_Wh"] = p.energy_Wh_export.value().total;
             }
-            if (p.energy_Wh_export.is_initialized() && p.energy_Wh_export.get().L1.is_initialized()) {
-                telemetry_data["energy_export_L1_Wh"] = p.energy_Wh_export.get().L1.get();
+            if (p.energy_Wh_export && p.energy_Wh_export.value().L1) {
+                telemetry_data["energy_export_L1_Wh"] = p.energy_Wh_export.value().L1.value();
             }
-            if (p.energy_Wh_export.is_initialized() && p.energy_Wh_export.get().L2.is_initialized()) {
-                telemetry_data["energy_export_L2_Wh"] = p.energy_Wh_export.get().L2.get();
+            if (p.energy_Wh_export && p.energy_Wh_export.value().L2) {
+                telemetry_data["energy_export_L2_Wh"] = p.energy_Wh_export.value().L2.value();
             }
-            if (p.energy_Wh_export.is_initialized() && p.energy_Wh_export.get().L3.is_initialized()) {
-                telemetry_data["energy_export_L3_Wh"] = p.energy_Wh_export.get().L3.get();
+            if (p.energy_Wh_export && p.energy_Wh_export.value().L3) {
+                telemetry_data["energy_export_L3_Wh"] = p.energy_Wh_export.value().L3.value();
             }
 
-            if (p.power_W.is_initialized()) {
-                telemetry_data["power_total_W"] = p.power_W.get().total;
+            if (p.power_W) {
+                telemetry_data["power_total_W"] = p.power_W.value().total;
             }
-            if (p.power_W.is_initialized() && p.power_W.get().L1.is_initialized()) {
-                telemetry_data["power_L1_W"] = p.power_W.get().L1.get();
+            if (p.power_W && p.power_W.value().L1) {
+                telemetry_data["power_L1_W"] = p.power_W.value().L1.value();
             }
-            if (p.power_W.is_initialized() && p.power_W.get().L2.is_initialized()) {
-                telemetry_data["power_L3_W"] = p.power_W.get().L2.get();
+            if (p.power_W && p.power_W.value().L2) {
+                telemetry_data["power_L3_W"] = p.power_W.value().L2.value();
             }
-            if (p.power_W.is_initialized() && p.power_W.get().L3.is_initialized()) {
-                telemetry_data["power_L3_W"] = p.power_W.get().L3.get();
+            if (p.power_W && p.power_W.value().L3) {
+                telemetry_data["power_L3_W"] = p.power_W.value().L3.value();
             }
 
-            if (p.VAR.is_initialized()) {
-                telemetry_data["var_total"] = p.VAR.get().total;
+            if (p.VAR) {
+                telemetry_data["var_total"] = p.VAR.value().total;
             }
-            if (p.VAR.is_initialized() && p.VAR.get().L1.is_initialized()) {
-                telemetry_data["var_L1"] = p.VAR.get().L1.get();
+            if (p.VAR && p.VAR.value().L1) {
+                telemetry_data["var_L1"] = p.VAR.value().L1.value();
             }
-            if (p.VAR.is_initialized() && p.VAR.get().L2.is_initialized()) {
-                telemetry_data["var_L1"] = p.VAR.get().L2.get();
+            if (p.VAR && p.VAR.value().L2) {
+                telemetry_data["var_L1"] = p.VAR.value().L2.value();
             }
-            if (p.VAR.is_initialized() && p.VAR.get().L3.is_initialized()) {
-                telemetry_data["var_L1"] = p.VAR.get().L3.get();
+            if (p.VAR && p.VAR.value().L3) {
+                telemetry_data["var_L1"] = p.VAR.value().L3.value();
             }
 
-            if (p.voltage_V.is_initialized() && p.voltage_V.get().L1.is_initialized()) {
-                telemetry_data["voltage_L1_V"] = p.voltage_V.get().L1.get();
+            if (p.voltage_V && p.voltage_V.value().L1) {
+                telemetry_data["voltage_L1_V"] = p.voltage_V.value().L1.value();
             }
-            if (p.voltage_V.is_initialized() && p.voltage_V.get().L2.is_initialized()) {
-                telemetry_data["voltage_L2_V"] = p.voltage_V.get().L2.get();
+            if (p.voltage_V && p.voltage_V.value().L2) {
+                telemetry_data["voltage_L2_V"] = p.voltage_V.value().L2.value();
             }
-            if (p.voltage_V.is_initialized() && p.voltage_V.get().L3.is_initialized()) {
-                telemetry_data["voltage_L3_V"] = p.voltage_V.get().L3.get();
+            if (p.voltage_V && p.voltage_V.value().L3) {
+                telemetry_data["voltage_L3_V"] = p.voltage_V.value().L3.value();
             }
-            if (p.voltage_V.is_initialized() && p.voltage_V.get().DC.is_initialized()) {
-                telemetry_data["voltage_DC_V"] = p.voltage_V.get().DC.get();
+            if (p.voltage_V && p.voltage_V.value().DC) {
+                telemetry_data["voltage_DC_V"] = p.voltage_V.value().DC.value();
             }
 
-            if (p.current_A.is_initialized() && p.current_A.get().L1.is_initialized()) {
-                telemetry_data["current_L1_A"] = p.current_A.get().L1.get();
+            if (p.current_A && p.current_A.value().L1) {
+                telemetry_data["current_L1_A"] = p.current_A.value().L1.value();
             }
-            if (p.current_A.is_initialized() && p.current_A.get().L2.is_initialized()) {
-                telemetry_data["current_L2_A"] = p.current_A.get().L2.get();
+            if (p.current_A && p.current_A.value().L2) {
+                telemetry_data["current_L2_A"] = p.current_A.value().L2.value();
             }
-            if (p.current_A.is_initialized() && p.current_A.get().L3.is_initialized()) {
-                telemetry_data["current_L3_A"] = p.current_A.get().L3.get();
+            if (p.current_A && p.current_A.value().L3) {
+                telemetry_data["current_L3_A"] = p.current_A.value().L3.value();
             }
-            if (p.current_A.is_initialized() && p.current_A.get().DC.is_initialized()) {
-                telemetry_data["current_DC_A"] = p.current_A.get().DC.get();
+            if (p.current_A && p.current_A.value().DC) {
+                telemetry_data["current_DC_A"] = p.current_A.value().DC.value();
             }
 
-            if (p.frequency_Hz.is_initialized()) {
-                telemetry_data["frequency_L1_Hz"] = p.frequency_Hz.get().L1;
+            if (p.frequency_Hz) {
+                telemetry_data["frequency_L1_Hz"] = p.frequency_Hz.value().L1;
             }
-            if (p.frequency_Hz.is_initialized() && p.frequency_Hz.get().L2.is_initialized()) {
-                telemetry_data["frequency_L2_Hz"] = p.frequency_Hz.get().L2.get();
+            if (p.frequency_Hz && p.frequency_Hz.value().L2) {
+                telemetry_data["frequency_L2_Hz"] = p.frequency_Hz.value().L2.value();
             }
-            if (p.frequency_Hz.is_initialized() && p.frequency_Hz.get().L3.is_initialized()) {
-                telemetry_data["frequency_L3_Hz"] = p.frequency_Hz.get().L3.get();
+            if (p.frequency_Hz && p.frequency_Hz.value().L3) {
+                telemetry_data["frequency_L3_Hz"] = p.frequency_Hz.value().L3.value();
             }
 
-            if (p.phase_seq_error.is_initialized()) {
-                telemetry_data["phase_seq_error"] = p.phase_seq_error.get();
+            if (p.phase_seq_error) {
+                telemetry_data["phase_seq_error"] = p.phase_seq_error.value();
             }
 
             // Publish as external telemetry data
diff --git a/modules/EvseManager/SessionLog.cpp b/modules/EvseManager/SessionLog.cpp
index 4a0e0a0da..0a551fe5c 100644
--- a/modules/EvseManager/SessionLog.cpp
+++ b/modules/EvseManager/SessionLog.cpp
@@ -36,7 +36,7 @@ void SessionLog::enable() {
     enabled = true;
 }
 
-boost::optional<std::string> SessionLog::startSession(const std::string& suffix_string) {
+std::optional<std::string> SessionLog::startSession(const std::string& suffix_string) {
     if (enabled) {
         if (session_active) {
             stopSession();
@@ -93,10 +93,10 @@ boost::optional<std::string> SessionLog::startSession(const std::string& suffix_
                         "</style>";
         logfile_html << "</head><body><table class=\"log\">\n";
         sys("Session logging started.");
-        return boost::optional<std::string>(logpath);
+        return logpath;
     }
 
-    return boost::optional<std::string>();
+    return std::string();
 }
 
 void SessionLog::stopSession() {
diff --git a/modules/EvseManager/SessionLog.hpp b/modules/EvseManager/SessionLog.hpp
index 0f1b266e5..52bc64c88 100644
--- a/modules/EvseManager/SessionLog.hpp
+++ b/modules/EvseManager/SessionLog.hpp
@@ -5,7 +5,7 @@
 
 #include <fstream>
 #include <string>
-#include <boost/optional.hpp>
+#include <optional>
 
 namespace module {
 /*
@@ -19,7 +19,7 @@ class SessionLog {
 
     void setPath(const std::string& path);
     void enable();
-    boost::optional<std::string> startSession(const std::string& suffix_string);
+    std::optional<std::string> startSession(const std::string& suffix_string);
     void stopSession();
 
     void car(bool iso15118, const std::string& msg);
diff --git a/modules/EvseManager/evse/evse_managerImpl.cpp b/modules/EvseManager/evse/evse_managerImpl.cpp
index b618fd054..70660804e 100644
--- a/modules/EvseManager/evse/evse_managerImpl.cpp
+++ b/modules/EvseManager/evse/evse_managerImpl.cpp
@@ -162,8 +162,8 @@ void evse_managerImpl::ready() {
 
             auto p = mod->get_latest_powermeter_data_billing();
             transaction_started.energy_Wh_import = p.energy_Wh_import.total;
-            if (p.energy_Wh_export.is_initialized()) {
-                transaction_started.energy_Wh_export.emplace(p.energy_Wh_export.get().total);
+            if (p.energy_Wh_export) {
+                transaction_started.energy_Wh_export.emplace(p.energy_Wh_export.value().total);
             }
 
             if (mod->is_reserved()) {
@@ -183,8 +183,8 @@ void evse_managerImpl::ready() {
                                                     {"energy_counter_import_wh", p.energy_Wh_import.total},
                                                     {"id_tag", transaction_started.id_tag}};
 
-            if (p.energy_Wh_export.is_initialized()) {
-                telemetry_data["energy_counter_export_wh"] = p.energy_Wh_export.get().total;
+            if (p.energy_Wh_export) {
+                telemetry_data["energy_counter_export_wh"] = p.energy_Wh_export.value().total;
             }
             mod->telemetry.publish("session", "events", telemetry_data);
 
@@ -197,8 +197,8 @@ void evse_managerImpl::ready() {
 
             auto p = mod->get_latest_powermeter_data_billing();
             transaction_finished.energy_Wh_import = p.energy_Wh_import.total;
-            if (p.energy_Wh_export.is_initialized()) {
-                transaction_finished.energy_Wh_export.emplace(p.energy_Wh_export.get().total);
+            if (p.energy_Wh_export) {
+                transaction_finished.energy_Wh_export.emplace(p.energy_Wh_export.value().total);
             }
 
             auto reason = mod->charger->getTransactionFinishedReason();
@@ -222,8 +222,8 @@ void evse_managerImpl::ready() {
                 {"energy_counter_import_wh", p.energy_Wh_import.total},
                 {"reason", types::evse_manager::stop_transaction_reason_to_string(reason)}};
 
-            if (p.energy_Wh_export.is_initialized()) {
-                telemetry_data["energy_counter_export_wh"] = p.energy_Wh_export.get().total;
+            if (p.energy_Wh_export) {
+                telemetry_data["energy_counter_export_wh"] = p.energy_Wh_export.value().total;
             }
 
             mod->telemetry.publish("session", "events", telemetry_data);
diff --git a/modules/EvseSlac/main/slacImpl.cpp b/modules/EvseSlac/main/slacImpl.cpp
index 32231033a..5315d48e5 100644
--- a/modules/EvseSlac/main/slacImpl.cpp
+++ b/modules/EvseSlac/main/slacImpl.cpp
@@ -68,7 +68,7 @@ void slacImpl::run() {
 
     callbacks.signal_state = [this](const std::string& value) { publish_state(value); };
 
-    callbacks.signal_error_routine_request = [this]() { publish_request_error_routine(boost::blank()); };
+    callbacks.signal_error_routine_request = [this]() { publish_request_error_routine(nullptr); };
 
     callbacks.log = [](const std::string& text) { EVLOG_debug << text; };
 
diff --git a/modules/EvseV2G/charger/ISO15118_chargerImpl.cpp b/modules/EvseV2G/charger/ISO15118_chargerImpl.cpp
index ece5ac9f8..7fa690b1b 100644
--- a/modules/EvseV2G/charger/ISO15118_chargerImpl.cpp
+++ b/modules/EvseV2G/charger/ISO15118_chargerImpl.cpp
@@ -313,10 +313,10 @@ void ISO15118_chargerImpl::handle_set_MeterInfo(types::powermeter::Powermeter& p
     v2g_ctx->meter_info.meter_info_is_used = 1;
     v2g_ctx->meter_info.meter_reading = powermeter.energy_Wh_import.total;
 
-    if (powermeter.meter_id.is_initialized() == true) {
-        uint8_t len = powermeter.meter_id.get().length();
+    if (powermeter.meter_id) {
+        uint8_t len = powermeter.meter_id->length();
         if (len < iso1MeterInfoType_MeterID_CHARACTERS_SIZE) {
-            memcpy(v2g_ctx->meter_info.meter_id.bytes, powermeter.meter_id.get().c_str(), len);
+            memcpy(v2g_ctx->meter_info.meter_id.bytes, powermeter.meter_id->c_str(), len);
             v2g_ctx->meter_info.meter_id.bytesLen = len;
         } else {
             dlog(DLOG_LEVEL_WARNING, "MeterID_CHARACTERS_SIZEexceeded (received: %u, max: %u)", len,
diff --git a/modules/EvseV2G/connection.cpp b/modules/EvseV2G/connection.cpp
index de0e03cfd..c0704a88d 100644
--- a/modules/EvseV2G/connection.cpp
+++ b/modules/EvseV2G/connection.cpp
@@ -458,7 +458,7 @@ ssize_t connection_write(struct v2g_connection* conn, unsigned char* buf, size_t
  */
 static void connection_teardown(struct v2g_connection* conn) {
     if (conn->ctx->session.is_charging == true) {
-        conn->ctx->p_charger->publish_currentDemand_Finished(boost::blank{});
+        conn->ctx->p_charger->publish_currentDemand_Finished(nullptr);
 
         if (conn->ctx->is_dc_charger == true) {
             conn->ctx->p_charger->publish_DC_Open_Contactor(true);
diff --git a/modules/EvseV2G/din_server.cpp b/modules/EvseV2G/din_server.cpp
index c18dfafb7..f020464db 100644
--- a/modules/EvseV2G/din_server.cpp
+++ b/modules/EvseV2G/din_server.cpp
@@ -631,7 +631,7 @@ static enum v2g_event handle_din_power_delivery(struct v2g_connection* conn) {
     publish_din_power_delivery_req(conn->ctx, req);
 
     if (req->ReadyToChargeState == (int)0) {
-        conn->ctx->p_charger->publish_currentDemand_Finished(boost::blank{});
+        conn->ctx->p_charger->publish_currentDemand_Finished(nullptr);
         conn->ctx->p_charger->publish_DC_Open_Contactor(true);
         conn->ctx->session.is_charging = false;
     }
@@ -944,7 +944,7 @@ enum v2g_event din_handle_request(v2g_connection* conn) {
     if (exi_in->V2G_Message.Body.CurrentDemandReq_isUsed) {
         dlog(DLOG_LEVEL_TRACE, "Handling CurrentDemandReq");
         if (conn->ctx->last_v2g_msg == V2G_POWER_DELIVERY_MSG) {
-            conn->ctx->p_charger->publish_currentDemand_Started(boost::blank{});
+            conn->ctx->p_charger->publish_currentDemand_Started(nullptr);
             conn->ctx->session.is_charging = true;
         }
         conn->ctx->current_v2g_msg = V2G_CURRENT_DEMAND_MSG;
@@ -975,7 +975,7 @@ enum v2g_event din_handle_request(v2g_connection* conn) {
         conn->ctx->current_v2g_msg = V2G_AUTHORIZATION_MSG;
         if (conn->ctx->last_v2g_msg != V2G_AUTHORIZATION_MSG) {
             dlog(DLOG_LEVEL_INFO, "Auth-phase started");
-            conn->ctx->p_charger->publish_Require_Auth_EIM(boost::blank{});
+            conn->ctx->p_charger->publish_Require_Auth_EIM(nullptr);
         }
         exi_out->V2G_Message.Body.ContractAuthenticationRes_isUsed = 1u;
         init_dinContractAuthenticationResType(&exi_out->V2G_Message.Body.ContractAuthenticationRes);
@@ -1001,7 +1001,7 @@ enum v2g_event din_handle_request(v2g_connection* conn) {
         dlog(DLOG_LEVEL_TRACE, "Handling CableCheckReq");
         conn->ctx->current_v2g_msg = V2G_CABLE_CHECK_MSG;
         if (conn->ctx->last_v2g_msg == V2G_CHARGE_PARAMETER_DISCOVERY_MSG) {
-            conn->ctx->p_charger->publish_Start_CableCheck(boost::blank{});
+            conn->ctx->p_charger->publish_Start_CableCheck(nullptr);
             dlog(DLOG_LEVEL_INFO, "Isolation-phase started");
         }
         exi_out->V2G_Message.Body.CableCheckRes_isUsed = 1u;
diff --git a/modules/EvseV2G/iso_server.cpp b/modules/EvseV2G/iso_server.cpp
index 2f521fd66..62bb8f598 100644
--- a/modules/EvseV2G/iso_server.cpp
+++ b/modules/EvseV2G/iso_server.cpp
@@ -1561,7 +1561,7 @@ static enum v2g_event handle_iso_power_delivery(struct v2g_connection* conn) {
 
     switch (req->ChargeProgress) {
     case iso1chargeProgressType_Start:
-        conn->ctx->p_charger->publish_V2G_Setup_Finished(boost::blank{});
+        conn->ctx->p_charger->publish_V2G_Setup_Finished(nullptr);
 
         if (conn->ctx->is_dc_charger == false) {
             // TODO: For AC charging wait for CP state C or D , before transmitting of the response. CP state is checked
@@ -1604,7 +1604,7 @@ static enum v2g_event handle_iso_power_delivery(struct v2g_connection* conn) {
             // state is checked by other module
             conn->ctx->p_charger->publish_AC_Open_Contactor(true);
         } else {
-            conn->ctx->p_charger->publish_currentDemand_Finished(boost::blank{});
+            conn->ctx->p_charger->publish_currentDemand_Finished(nullptr);
             conn->ctx->p_charger->publish_DC_Open_Contactor(true);
         }
         break;
@@ -2177,7 +2177,7 @@ enum v2g_event iso_handle_request(v2g_connection* conn) {
     if (exi_in->V2G_Message.Body.CurrentDemandReq_isUsed) {
         dlog(DLOG_LEVEL_TRACE, "Handling CurrentDemandReq");
         if (conn->ctx->last_v2g_msg == V2G_POWER_DELIVERY_MSG) {
-            conn->ctx->p_charger->publish_currentDemand_Started(boost::blank{});
+            conn->ctx->p_charger->publish_currentDemand_Started(nullptr);
             conn->ctx->session.is_charging = true;
         }
         conn->ctx->current_v2g_msg = V2G_CURRENT_DEMAND_MSG;
@@ -2219,7 +2219,7 @@ enum v2g_event iso_handle_request(v2g_connection* conn) {
         conn->ctx->current_v2g_msg = V2G_AUTHORIZATION_MSG;
         if (conn->ctx->last_v2g_msg != V2G_AUTHORIZATION_MSG) {
             if (conn->ctx->session.iso_selected_payment_option == iso1paymentOptionType_ExternalPayment) {
-                conn->ctx->p_charger->publish_Require_Auth_EIM(boost::blank{});
+                conn->ctx->p_charger->publish_Require_Auth_EIM(nullptr);
             }
         }
         exi_out->V2G_Message.Body.AuthorizationRes_isUsed = 1u;
@@ -2273,7 +2273,7 @@ enum v2g_event iso_handle_request(v2g_connection* conn) {
         conn->ctx->current_v2g_msg = V2G_CABLE_CHECK_MSG;
         /* At first send mqtt charging phase signal to the customer interface */
         if (V2G_CHARGE_PARAMETER_DISCOVERY_MSG == conn->ctx->last_v2g_msg) {
-            conn->ctx->p_charger->publish_Start_CableCheck(boost::blank{});
+            conn->ctx->p_charger->publish_Start_CableCheck(nullptr);
         }
 
         exi_out->V2G_Message.Body.CableCheckRes_isUsed = 1u;
diff --git a/modules/EvseV2G/v2g_ctx.cpp b/modules/EvseV2G/v2g_ctx.cpp
index dc4216d40..2c9244850 100644
--- a/modules/EvseV2G/v2g_ctx.cpp
+++ b/modules/EvseV2G/v2g_ctx.cpp
@@ -444,7 +444,7 @@ void publish_DC_EVRemainingTime(struct v2g_context* ctx, const float& v2g_dc_ev_
         if (ctx->ev_v2g_data.remaining_time_to_full_soc != v2g_dc_ev_remaining_time_to_full_soc) {
             std::time_t time_to_full_soc = time_now_in_sec + v2g_dc_ev_remaining_time_to_full_soc;
             std::strftime(buffer, sizeof(buffer), format, std::gmtime(&time_to_full_soc));
-            DC_EVRemainingTime.EV_RemainingTimeToFullSoC = static_cast<boost::optional<std::string>>(buffer);
+            DC_EVRemainingTime.EV_RemainingTimeToFullSoC = std::string(buffer);
             ctx->ev_v2g_data.remaining_time_to_full_soc = v2g_dc_ev_remaining_time_to_full_soc;
             publish_message = true;
         }
@@ -453,7 +453,7 @@ void publish_DC_EVRemainingTime(struct v2g_context* ctx, const float& v2g_dc_ev_
         if (ctx->ev_v2g_data.remaining_time_to_bulk_soc != v2g_dc_ev_remaining_time_to_bulk_soc) {
             std::time_t time_to_bulk_soc = time_now_in_sec + v2g_dc_ev_remaining_time_to_bulk_soc;
             std::strftime(buffer, sizeof(buffer), format, std::gmtime(&time_to_bulk_soc));
-            DC_EVRemainingTime.EV_RemainingTimeToBulkSoC = static_cast<boost::optional<std::string>>(buffer);
+            DC_EVRemainingTime.EV_RemainingTimeToBulkSoC = std::string(buffer);
             ctx->ev_v2g_data.remaining_time_to_bulk_soc = v2g_dc_ev_remaining_time_to_bulk_soc;
             publish_message = true;
         }
diff --git a/modules/Example/example/exampleImpl.cpp b/modules/Example/example/exampleImpl.cpp
index cef6d87de..63bfc7d10 100644
--- a/modules/Example/example/exampleImpl.cpp
+++ b/modules/Example/example/exampleImpl.cpp
@@ -33,7 +33,7 @@ bool exampleImpl::handle_uses_something(std::string& key) {
 
     auto ret = mod->r_kvs->call_load(key);
 
-    Array arr = boost::get<Array>(ret);
+    Array arr = std::get<Array>(ret);
 
     EVLOG_debug << "loaded array: " << arr << ", original array: " << test_array;
 
diff --git a/modules/Example/store/kvsImpl.cpp b/modules/Example/store/kvsImpl.cpp
index 1ccca9b5d..f86556cc7 100644
--- a/modules/Example/store/kvsImpl.cpp
+++ b/modules/Example/store/kvsImpl.cpp
@@ -12,11 +12,11 @@ void kvsImpl::ready() {
 }
 
 void kvsImpl::handle_store(std::string& key,
-                           boost::variant<boost::blank, Array, Object, bool, double, int, std::string>& value) {
+                           std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>& value) {
     mod->r_kvs->call_store(key, value);
 };
 
-boost::variant<boost::blank, Array, Object, bool, double, int, std::string> kvsImpl::handle_load(std::string& key) {
+std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string> kvsImpl::handle_load(std::string& key) {
     return mod->r_kvs->call_load(key);
 };
 
diff --git a/modules/Example/store/kvsImpl.hpp b/modules/Example/store/kvsImpl.hpp
index 52b5703aa..769650caf 100644
--- a/modules/Example/store/kvsImpl.hpp
+++ b/modules/Example/store/kvsImpl.hpp
@@ -35,8 +35,8 @@ class kvsImpl : public kvsImplBase {
     // command handler functions (virtual)
     virtual void
     handle_store(std::string& key,
-                 boost::variant<boost::blank, Array, Object, bool, double, int, std::string>& value) override;
-    virtual boost::variant<boost::blank, Array, Object, bool, double, int, std::string>
+                 std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>& value) override;
+    virtual std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>
     handle_load(std::string& key) override;
     virtual void handle_delete(std::string& key) override;
     virtual bool handle_exists(std::string& key) override;
diff --git a/modules/GenericPowermeter/main/powermeterImpl.cpp b/modules/GenericPowermeter/main/powermeterImpl.cpp
index 5edf6bd9c..d2ab54b9a 100644
--- a/modules/GenericPowermeter/main/powermeterImpl.cpp
+++ b/modules/GenericPowermeter/main/powermeterImpl.cpp
@@ -67,161 +67,161 @@ void powermeterImpl::init_default_values() {
         } else if (register_data.type == ENERGY_WH_EXPORT_TOTAL) {
             types::units::Energy energy_out;
             if (this->pm_last_values.energy_Wh_export.has_value()) {
-                energy_out = this->pm_last_values.energy_Wh_export.get();
+                energy_out = this->pm_last_values.energy_Wh_export.value();
             }
             energy_out.total = 0.0f;
             this->pm_last_values.energy_Wh_export = energy_out;
         } else if (register_data.type == ENERGY_WH_EXPORT_L1) {
             types::units::Energy energy_out;
             if (this->pm_last_values.energy_Wh_export.has_value()) {
-                energy_out = this->pm_last_values.energy_Wh_export.get();
+                energy_out = this->pm_last_values.energy_Wh_export.value();
             }
             energy_out.L1 = 0.0f;
             this->pm_last_values.energy_Wh_export = energy_out;
         } else if (register_data.type == ENERGY_WH_EXPORT_L2) {
             types::units::Energy energy_out;
             if (this->pm_last_values.energy_Wh_export.has_value()) {
-                energy_out = this->pm_last_values.energy_Wh_export.get();
+                energy_out = this->pm_last_values.energy_Wh_export.value();
             }
             energy_out.L2 = 0.0f;
             this->pm_last_values.energy_Wh_export = energy_out;
         } else if (register_data.type == ENERGY_WH_EXPORT_L3) {
             types::units::Energy energy_out;
             if (this->pm_last_values.energy_Wh_export.has_value()) {
-                energy_out = this->pm_last_values.energy_Wh_export.get();
+                energy_out = this->pm_last_values.energy_Wh_export.value();
             }
             energy_out.L3 = 0.0f;
             this->pm_last_values.energy_Wh_export = energy_out;
         } else if (register_data.type == POWER_W_TOTAL) {
             types::units::Power pwr;
             if (this->pm_last_values.power_W.has_value()) {
-                pwr = this->pm_last_values.power_W.get();
+                pwr = this->pm_last_values.power_W.value();
             }
             pwr.total = 0.0f;
             this->pm_last_values.power_W = pwr;
         } else if (register_data.type == POWER_W_L1) {
             types::units::Power pwr;
             if (this->pm_last_values.power_W.has_value()) {
-                pwr = this->pm_last_values.power_W.get();
+                pwr = this->pm_last_values.power_W.value();
             }
             pwr.L1 = 0.0f;
             this->pm_last_values.power_W = pwr;
         } else if (register_data.type == POWER_W_L2) {
             types::units::Power pwr;
             if (this->pm_last_values.power_W.has_value()) {
-                pwr = this->pm_last_values.power_W.get();
+                pwr = this->pm_last_values.power_W.value();
             }
             pwr.L2 = 0.0f;
             this->pm_last_values.power_W = pwr;
         } else if (register_data.type == POWER_W_L3) {
             types::units::Power pwr;
             if (this->pm_last_values.power_W.has_value()) {
-                pwr = this->pm_last_values.power_W.get();
+                pwr = this->pm_last_values.power_W.value();
             }
             pwr.L3 = 0.0f;
             this->pm_last_values.power_W = pwr;
         } else if (register_data.type == VOLTAGE_V_DC) {
             types::units::Voltage volt;
             if (this->pm_last_values.voltage_V.has_value()) {
-                volt = this->pm_last_values.voltage_V.get();
+                volt = this->pm_last_values.voltage_V.value();
             }
             volt.DC = 0.0f;
             this->pm_last_values.voltage_V = volt;
         } else if (register_data.type == VOLTAGE_V_L1) {
             types::units::Voltage volt;
             if (this->pm_last_values.voltage_V.has_value()) {
-                volt = this->pm_last_values.voltage_V.get();
+                volt = this->pm_last_values.voltage_V.value();
             }
             volt.L1 = 0.0f;
             this->pm_last_values.voltage_V = volt;
         } else if (register_data.type == VOLTAGE_V_L2) {
             types::units::Voltage volt;
             if (this->pm_last_values.voltage_V.has_value()) {
-                volt = this->pm_last_values.voltage_V.get();
+                volt = this->pm_last_values.voltage_V.value();
             }
             volt.L2 = 0.0f;
             this->pm_last_values.voltage_V = volt;
         } else if (register_data.type == VOLTAGE_V_L3) {
             types::units::Voltage volt;
             if (this->pm_last_values.voltage_V.has_value()) {
-                volt = this->pm_last_values.voltage_V.get();
+                volt = this->pm_last_values.voltage_V.value();
             }
             volt.L3 = 0.0f;
             this->pm_last_values.voltage_V = volt;
         } else if (register_data.type == REACTIVE_POWER_VAR_TOTAL) {
             types::units::ReactivePower var;
             if (this->pm_last_values.VAR.has_value()) {
-                var = this->pm_last_values.VAR.get();
+                var = this->pm_last_values.VAR.value();
             }
             var.total = 0.0f;
             this->pm_last_values.VAR = var;
         } else if (register_data.type == REACTIVE_POWER_VAR_L1) {
             types::units::ReactivePower var;
             if (this->pm_last_values.VAR.has_value()) {
-                var = this->pm_last_values.VAR.get();
+                var = this->pm_last_values.VAR.value();
             }
             var.L1 = 0.0f;
             this->pm_last_values.VAR = var;
         } else if (register_data.type == REACTIVE_POWER_VAR_L2) {
             types::units::ReactivePower var;
             if (this->pm_last_values.VAR.has_value()) {
-                var = this->pm_last_values.VAR.get();
+                var = this->pm_last_values.VAR.value();
             }
             var.L2 = 0.0f;
             this->pm_last_values.VAR = var;
         } else if (register_data.type == REACTIVE_POWER_VAR_L3) {
             types::units::ReactivePower var;
             if (this->pm_last_values.VAR.has_value()) {
-                var = this->pm_last_values.VAR.get();
+                var = this->pm_last_values.VAR.value();
             }
             var.L3 = 0.0f;
             this->pm_last_values.VAR = var;
         } else if (register_data.type == CURRENT_A_DC) {
             types::units::Current amp;
             if (this->pm_last_values.current_A.has_value()) {
-                amp = this->pm_last_values.current_A.get();
+                amp = this->pm_last_values.current_A.value();
             }
             amp.DC = 0.0f;
             this->pm_last_values.current_A = amp;
         } else if (register_data.type == CURRENT_A_L1) {
             types::units::Current amp;
             if (this->pm_last_values.current_A.has_value()) {
-                amp = this->pm_last_values.current_A.get();
+                amp = this->pm_last_values.current_A.value();
             }
             amp.L1 = 0.0f;
             this->pm_last_values.current_A = amp;
         } else if (register_data.type == CURRENT_A_L2) {
             types::units::Current amp;
             if (this->pm_last_values.current_A.has_value()) {
-                amp = this->pm_last_values.current_A.get();
+                amp = this->pm_last_values.current_A.value();
             }
             amp.L2 = 0.0f;
             this->pm_last_values.current_A = amp;
         } else if (register_data.type == CURRENT_A_L3) {
             types::units::Current amp;
             if (this->pm_last_values.current_A.has_value()) {
-                amp = this->pm_last_values.current_A.get();
+                amp = this->pm_last_values.current_A.value();
             }
             amp.L3 = 0.0f;
             this->pm_last_values.current_A = amp;
         } else if (register_data.type == FREQUENCY_HZ_L1) {
             types::units::Frequency freq;
             if (this->pm_last_values.frequency_Hz.has_value()) {
-                freq = this->pm_last_values.frequency_Hz.get();
+                freq = this->pm_last_values.frequency_Hz.value();
             }
             freq.L1 = 0.0f;
             this->pm_last_values.frequency_Hz = freq;
         } else if (register_data.type == FREQUENCY_HZ_L2) {
             types::units::Frequency freq;
             if (this->pm_last_values.frequency_Hz.has_value()) {
-                freq = this->pm_last_values.frequency_Hz.get();
+                freq = this->pm_last_values.frequency_Hz.value();
             }
             freq.L2 = 0.0f;
             this->pm_last_values.frequency_Hz = freq;
         } else if (register_data.type == FREQUENCY_HZ_L3) {
             types::units::Frequency freq;
             if (this->pm_last_values.frequency_Hz.has_value()) {
-                freq = this->pm_last_values.frequency_Hz.get();
+                freq = this->pm_last_values.frequency_Hz.value();
             }
             freq.L3 = 0.0f;
             this->pm_last_values.frequency_Hz = freq;
@@ -370,7 +370,7 @@ void powermeterImpl::process_response(const RegisterData& register_data,
 
         int16_t exponent{0};
         if (exponent_message.value.has_value()) {
-            exponent = exponent_message.value.get()[0];
+            exponent = exponent_message.value.value()[0];
         } else {
             exponent = 0.0;
         }
@@ -392,95 +392,95 @@ void powermeterImpl::process_response(const RegisterData& register_data,
             energy_in.L3 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.energy_Wh_import = energy_in;
         } else if (register_data.type == ENERGY_WH_EXPORT_TOTAL) {
-            types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.get();
+            types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
             energy_out.total = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.energy_Wh_export = energy_out;
         } else if (register_data.type == ENERGY_WH_EXPORT_L1) {
-            types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.get();
+            types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
             energy_out.L1 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.energy_Wh_export = energy_out;
         } else if (register_data.type == ENERGY_WH_EXPORT_L2) {
-            types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.get();
+            types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
             energy_out.L2 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.energy_Wh_export = energy_out;
         } else if (register_data.type == ENERGY_WH_EXPORT_L3) {
-            types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.get();
+            types::units::Energy energy_out = this->pm_last_values.energy_Wh_export.value();
             energy_out.L3 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.energy_Wh_export = energy_out;
         } else if (register_data.type == POWER_W_TOTAL) {
-            types::units::Power power = this->pm_last_values.power_W.get();
+            types::units::Power power = this->pm_last_values.power_W.value();
             power.total = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.power_W = power;
         } else if (register_data.type == POWER_W_L1) {
-            types::units::Power power = this->pm_last_values.power_W.get();
+            types::units::Power power = this->pm_last_values.power_W.value();
             power.L1 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.power_W = power;
         } else if (register_data.type == POWER_W_L2) {
-            types::units::Power power = this->pm_last_values.power_W.get();
+            types::units::Power power = this->pm_last_values.power_W.value();
             power.L2 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.power_W = power;
         } else if (register_data.type == POWER_W_L3) {
-            types::units::Power power = this->pm_last_values.power_W.get();
+            types::units::Power power = this->pm_last_values.power_W.value();
             power.L3 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.power_W = power;
         } else if (register_data.type == VOLTAGE_V_DC) {
-            types::units::Voltage volt = this->pm_last_values.voltage_V.get();
+            types::units::Voltage volt = this->pm_last_values.voltage_V.value();
             volt.DC = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.voltage_V = volt;
         } else if (register_data.type == VOLTAGE_V_L1) {
-            types::units::Voltage volt = this->pm_last_values.voltage_V.get();
+            types::units::Voltage volt = this->pm_last_values.voltage_V.value();
             volt.L1 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.voltage_V = volt;
         } else if (register_data.type == VOLTAGE_V_L2) {
-            types::units::Voltage volt = this->pm_last_values.voltage_V.get();
+            types::units::Voltage volt = this->pm_last_values.voltage_V.value();
             volt.L2 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.voltage_V = volt;
         } else if (register_data.type == VOLTAGE_V_L3) {
-            types::units::Voltage volt = this->pm_last_values.voltage_V.get();
+            types::units::Voltage volt = this->pm_last_values.voltage_V.value();
             volt.L3 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.voltage_V = volt;
         } else if (register_data.type == REACTIVE_POWER_VAR_TOTAL) {
-            types::units::ReactivePower var = this->pm_last_values.VAR.get();
+            types::units::ReactivePower var = this->pm_last_values.VAR.value();
             var.total = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.VAR = var;
         } else if (register_data.type == REACTIVE_POWER_VAR_L1) {
-            types::units::ReactivePower var = this->pm_last_values.VAR.get();
+            types::units::ReactivePower var = this->pm_last_values.VAR.value();
             var.L1 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.VAR = var;
         } else if (register_data.type == REACTIVE_POWER_VAR_L2) {
-            types::units::ReactivePower var = this->pm_last_values.VAR.get();
+            types::units::ReactivePower var = this->pm_last_values.VAR.value();
             var.L2 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.VAR = var;
         } else if (register_data.type == REACTIVE_POWER_VAR_L3) {
-            types::units::ReactivePower var = this->pm_last_values.VAR.get();
+            types::units::ReactivePower var = this->pm_last_values.VAR.value();
             var.L3 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.VAR = var;
         } else if (register_data.type == CURRENT_A_DC) {
-            types::units::Current amp = this->pm_last_values.current_A.get();
+            types::units::Current amp = this->pm_last_values.current_A.value();
             amp.DC = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.current_A = amp;
         } else if (register_data.type == CURRENT_A_L1) {
-            types::units::Current amp = this->pm_last_values.current_A.get();
+            types::units::Current amp = this->pm_last_values.current_A.value();
             amp.L1 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.current_A = amp;
         } else if (register_data.type == CURRENT_A_L2) {
-            types::units::Current amp = this->pm_last_values.current_A.get();
+            types::units::Current amp = this->pm_last_values.current_A.value();
             amp.L2 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.current_A = amp;
         } else if (register_data.type == CURRENT_A_L3) {
-            types::units::Current amp = this->pm_last_values.current_A.get();
+            types::units::Current amp = this->pm_last_values.current_A.value();
             amp.L3 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.current_A = amp;
         } else if (register_data.type == FREQUENCY_HZ_L1) {
-            types::units::Frequency freq = this->pm_last_values.frequency_Hz.get();
+            types::units::Frequency freq = this->pm_last_values.frequency_Hz.value();
             freq.L1 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.frequency_Hz = freq;
         } else if (register_data.type == FREQUENCY_HZ_L2) {
-            types::units::Frequency freq = this->pm_last_values.frequency_Hz.get();
+            types::units::Frequency freq = this->pm_last_values.frequency_Hz.value();
             freq.L2 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.frequency_Hz = freq;
         } else if (register_data.type == FREQUENCY_HZ_L3) {
-            types::units::Frequency freq = this->pm_last_values.frequency_Hz.get();
+            types::units::Frequency freq = this->pm_last_values.frequency_Hz.value();
             freq.L3 = merge_register_values_into_element(register_data, exponent, register_message);
             this->pm_last_values.frequency_Hz = freq;
         } else {
@@ -495,7 +495,7 @@ float powermeterImpl::merge_register_values_into_element(const RegisterData& reg
                                                          const types::serial_comm_hub_requests::Result& reg_message) {
     if (reg_message.value.has_value()) {
         uint32_t value{0};
-        auto& reg_value = reg_message.value.get();
+        auto& reg_value = reg_message.value.value();
         if (reg_data.num_registers == 1 && reg_value.size() == 1) {
             value = reg_value.at(0);
         } else if (reg_data.num_registers == 2 && reg_value.size() == 2) {
@@ -518,11 +518,11 @@ float powermeterImpl::merge_register_values_into_element(const RegisterData& reg
 void powermeterImpl::output_error_with_content(const types::serial_comm_hub_requests::Result& response) {
     std::stringstream ss;
 
-    if (response.value.has_value()) {
-        for (size_t i = 0; i < response.value.get().size(); i++) {
+    if (response.value) {
+        for (size_t i = 0; i < response.value->size(); i++) {
             if (i != 0)
                 ss << ", ";
-            ss << "0x" << std::setfill('0') << std::setw(2) << std::hex << int(response.value.get()[i]);
+            ss << "0x" << std::setfill('0') << std::setw(2) << std::hex << int(response.value.value()[i]);
         }
     }
 
diff --git a/modules/OCPP/OCPP.cpp b/modules/OCPP/OCPP.cpp
index 4f7a07ff8..1f80e0b47 100644
--- a/modules/OCPP/OCPP.cpp
+++ b/modules/OCPP/OCPP.cpp
@@ -210,7 +210,7 @@ void OCPP::init() {
     // int32_t reservation_id, CiString<20> auth_token, DateTime expiry_time, std::string parent_id
     this->charge_point->register_reserve_now_callback([this](int32_t reservation_id, int32_t connector,
                                                              ocpp::DateTime expiryDate, ocpp::CiString<20> idTag,
-                                                             boost::optional<ocpp::CiString<20>> parent_id) {
+                                                             std::optional<ocpp::CiString<20>> parent_id) {
         types::reservation::Reservation reservation;
         reservation.id_token = idTag.get();
         reservation.reservation_id = reservation_id;
@@ -447,7 +447,7 @@ void OCPP::init() {
                 const auto session_id = session_event.uuid;
                 const auto id_token = transaction_started.id_tag;
                 const auto signed_meter_value = transaction_started.signed_meter_value;
-                boost::optional<int32_t> reservation_id_opt = boost::none;
+                std::optional<int32_t> reservation_id_opt = std::nullopt;
                 if (transaction_started.reservation_id) {
                     reservation_id_opt.emplace(transaction_started.reservation_id.value());
                 }
@@ -474,7 +474,7 @@ void OCPP::init() {
                 const auto reason = ocpp::v16::conversions::string_to_reason(
                     types::evse_manager::stop_transaction_reason_to_string(transaction_finished.reason.value()));
                 const auto signed_meter_value = transaction_finished.signed_meter_value;
-                boost::optional<ocpp::CiString<20>> id_tag_opt = boost::none;
+                std::optional<ocpp::CiString<20>> id_tag_opt = std::nullopt;
                 if (transaction_finished.id_tag) {
                     id_tag_opt.emplace(ocpp::CiString<20>(transaction_finished.id_tag.value()));
                 }
diff --git a/modules/OCPP/auth_validator/auth_token_validatorImpl.cpp b/modules/OCPP/auth_validator/auth_token_validatorImpl.cpp
index a3d0f826d..2d77f5eb2 100644
--- a/modules/OCPP/auth_validator/auth_token_validatorImpl.cpp
+++ b/modules/OCPP/auth_validator/auth_token_validatorImpl.cpp
@@ -28,7 +28,7 @@ types::authorization::ValidationResult
 auth_token_validatorImpl::validate_pnc_request(const types::authorization::ProvidedIdToken& provided_token) {
 
     // preparing payload for data_transfer_pnc_authorize
-    boost::optional<std::vector<ocpp::v201::OCSPRequestData>> iso15118_certificate_hash_data_opt;
+    std::optional<std::vector<ocpp::v201::OCSPRequestData>> iso15118_certificate_hash_data_opt;
     if (provided_token.iso15118CertificateHashData.has_value()) {
         std::vector<ocpp::v201::OCSPRequestData> iso15118_certificate_hash_data;
         for (const auto& certificate_hash_data : provided_token.iso15118CertificateHashData.value()) {
@@ -76,10 +76,10 @@ auth_token_validatorImpl::validate_standard_request(const types::authorization::
     result.authorization_status = types::authorization::string_to_authorization_status(
         ocpp::v16::conversions::authorization_status_to_string(id_tag_info.status));
     if (id_tag_info.expiryDate) {
-        result.expiry_time = id_tag_info.expiryDate.get().to_rfc3339();
+        result.expiry_time = id_tag_info.expiryDate->to_rfc3339();
     }
     if (id_tag_info.parentIdTag) {
-        result.parent_id_token = id_tag_info.parentIdTag.get().get();
+        result.parent_id_token = id_tag_info.parentIdTag->get();
     }
     result.reason = "Validation by OCPP 1.6 Central System";
     return result;
diff --git a/modules/OCPP201/OCPP201.cpp b/modules/OCPP201/OCPP201.cpp
index cb9210872..d1fcc7a95 100644
--- a/modules/OCPP201/OCPP201.cpp
+++ b/modules/OCPP201/OCPP201.cpp
@@ -13,7 +13,7 @@ const std::string CERTS_DIR = "certs";
 namespace fs = std::filesystem;
 
 ocpp::v201::SampledValue get_sampled_value(const ocpp::v201::MeasurandEnum& measurand, const std::string& unit,
-                                           const boost::optional<ocpp::v201::PhaseEnum> phase) {
+                                           const std::optional<ocpp::v201::PhaseEnum> phase) {
     ocpp::v201::SampledValue sampled_value;
     ocpp::v201::UnitOfMeasure unit_of_measure;
     sampled_value.context = ocpp::v201::ReadingContextEnum::Sample_Periodic;
@@ -31,7 +31,7 @@ ocpp::v201::MeterValue get_meter_value(const types::powermeter::Powermeter& powe
 
     // Energy.Active.Import.Register
     ocpp::v201::SampledValue sampled_value =
-        get_sampled_value(ocpp::v201::MeasurandEnum::Energy_Active_Import_Register, "Wh", boost::none);
+        get_sampled_value(ocpp::v201::MeasurandEnum::Energy_Active_Import_Register, "Wh", std::nullopt);
     sampled_value.value = power_meter.energy_Wh_import.total;
     meter_value.sampledValue.push_back(sampled_value);
     if (power_meter.energy_Wh_import.L1.has_value()) {
@@ -56,7 +56,7 @@ ocpp::v201::MeterValue get_meter_value(const types::powermeter::Powermeter& powe
     // Energy.Active.Export.Register
     if (power_meter.energy_Wh_export.has_value()) {
         auto sampled_value =
-            get_sampled_value(ocpp::v201::MeasurandEnum::Energy_Active_Export_Register, "Wh", boost::none);
+            get_sampled_value(ocpp::v201::MeasurandEnum::Energy_Active_Export_Register, "Wh", std::nullopt);
         sampled_value.value = power_meter.energy_Wh_export.value().total;
         meter_value.sampledValue.push_back(sampled_value);
         if (power_meter.energy_Wh_export.value().L1.has_value()) {
@@ -81,7 +81,7 @@ ocpp::v201::MeterValue get_meter_value(const types::powermeter::Powermeter& powe
 
     // Power.Active.Import
     if (power_meter.power_W.has_value()) {
-        auto sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Power_Active_Import, "W", boost::none);
+        auto sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Power_Active_Import, "W", std::nullopt);
         sampled_value.value = power_meter.power_W.value().total;
         meter_value.sampledValue.push_back(sampled_value);
         if (power_meter.power_W.value().L1.has_value()) {
@@ -106,7 +106,7 @@ ocpp::v201::MeterValue get_meter_value(const types::powermeter::Powermeter& powe
 
     // Power.Reactive.Import
     if (power_meter.VAR.has_value()) {
-        auto sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Power_Reactive_Import, "var", boost::none);
+        auto sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Power_Reactive_Import, "var", std::nullopt);
         sampled_value.value = power_meter.VAR.value().total;
         meter_value.sampledValue.push_back(sampled_value);
         if (power_meter.VAR.value().L1.has_value()) {
@@ -131,7 +131,7 @@ ocpp::v201::MeterValue get_meter_value(const types::powermeter::Powermeter& powe
 
     // Current.Import
     if (power_meter.current_A.has_value()) {
-        auto sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Current_Import, "A", boost::none);
+        auto sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Current_Import, "A", std::nullopt);
         if (power_meter.current_A.value().L1.has_value()) {
             sampled_value =
                 get_sampled_value(ocpp::v201::MeasurandEnum::Current_Import, "A", ocpp::v201::PhaseEnum::L1);
@@ -151,7 +151,7 @@ ocpp::v201::MeterValue get_meter_value(const types::powermeter::Powermeter& powe
             meter_value.sampledValue.push_back(sampled_value);
         }
         if (power_meter.current_A.value().DC.has_value()) {
-            sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Current_Import, "A", boost::none);
+            sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Current_Import, "A", std::nullopt);
             sampled_value.value = power_meter.current_A.value().DC.value();
             meter_value.sampledValue.push_back(sampled_value);
         }
@@ -180,7 +180,7 @@ ocpp::v201::MeterValue get_meter_value(const types::powermeter::Powermeter& powe
             meter_value.sampledValue.push_back(sampled_value);
         }
         if (power_meter.voltage_V.value().DC.has_value()) {
-            sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Voltage, "V", boost::none);
+            sampled_value = get_sampled_value(ocpp::v201::MeasurandEnum::Voltage, "V", std::nullopt);
             sampled_value.value = power_meter.voltage_V.value().L1.value();
             meter_value.sampledValue.push_back(sampled_value);
         }
diff --git a/modules/OCPP201/auth_validator/auth_token_validatorImpl.cpp b/modules/OCPP201/auth_validator/auth_token_validatorImpl.cpp
index 42cba8395..fb8bc6ef8 100644
--- a/modules/OCPP201/auth_validator/auth_token_validatorImpl.cpp
+++ b/modules/OCPP201/auth_validator/auth_token_validatorImpl.cpp
@@ -74,11 +74,11 @@ void auth_token_validatorImpl::ready() {
 types::authorization::ValidationResult
 auth_token_validatorImpl::handle_validate_token(types::authorization::ProvidedIdToken& provided_token) {
         const auto id_token = get_id_token(provided_token);
-    boost::optional<ocpp::CiString<5500>> certificate_opt;
+    std::optional<ocpp::CiString<5500>> certificate_opt;
     if (provided_token.certificate.has_value()) {
         certificate_opt.emplace(provided_token.certificate.value());
     }
-    boost::optional<std::vector<ocpp::v201::OCSPRequestData>> ocsp_request_data_opt;
+    std::optional<std::vector<ocpp::v201::OCSPRequestData>> ocsp_request_data_opt;
     if (provided_token.iso15118CertificateHashData.has_value()) {
         ocsp_request_data_opt.emplace(get_ocsp_request_data(provided_token));
     }
diff --git a/modules/PacketSniffer/PacketSniffer.cpp b/modules/PacketSniffer/PacketSniffer.cpp
index a120ae9d1..95b29c3a8 100644
--- a/modules/PacketSniffer/PacketSniffer.cpp
+++ b/modules/PacketSniffer/PacketSniffer.cpp
@@ -36,9 +36,9 @@ void PacketSniffer::init() {
             if (!already_started) {
                 already_started = true;
                 capturing_stopped = false;
-                if (session_event.session_started.is_initialized() &&
-                    session_event.session_started.get().logging_path.is_initialized()) {
-                    std::thread(&PacketSniffer::capture, this, session_event.session_started.get().logging_path.get(),
+                if (session_event.session_started &&
+                    session_event.session_started->logging_path) {
+                    std::thread(&PacketSniffer::capture, this, session_event.session_started->logging_path.value(),
                                 session_event.uuid)
                         .detach();
                 }
diff --git a/modules/PersistentStore/main/kvsImpl.cpp b/modules/PersistentStore/main/kvsImpl.cpp
index ac76f959b..07f521a16 100644
--- a/modules/PersistentStore/main/kvsImpl.cpp
+++ b/modules/PersistentStore/main/kvsImpl.cpp
@@ -4,7 +4,6 @@
 #include "kvsImpl.hpp"
 
 #include <boost/filesystem.hpp>
-#include <boost/variant.hpp>
 
 namespace module {
 namespace main {
@@ -50,10 +49,10 @@ void kvsImpl::init() {
 void kvsImpl::ready() {
 }
 
-class TypeNameVisitor : public boost::static_visitor<std::string> {
+class TypeNameVisitor {
 public:
-    std::string operator()(const boost::blank& t) const {
-        return "boost::blank";
+    std::string operator()(std::nullptr_t t) const {
+        return "nullptr_t";
     }
 
     std::string operator()(const Array& t) const {
@@ -81,9 +80,9 @@ class TypeNameVisitor : public boost::static_visitor<std::string> {
     }
 };
 
-class StringValueVisitor : public boost::static_visitor<std::string> {
+class StringValueVisitor {
 public:
-    std::string operator()(const boost::blank& t) const {
+    std::string operator()(std::nullptr_t t) const {
         return "";
     }
 
@@ -118,9 +117,9 @@ class StringValueVisitor : public boost::static_visitor<std::string> {
 };
 
 void kvsImpl::handle_store(std::string& key,
-                           boost::variant<boost::blank, Array, Object, bool, double, int, std::string>& value) {
-    std::string type = boost::apply_visitor(TypeNameVisitor(), value);
-    std::string string_value = boost::apply_visitor(StringValueVisitor(), value);
+                           std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>& value) {
+    std::string type = std::visit(TypeNameVisitor(), value);
+    std::string string_value = std::visit(StringValueVisitor(), value);
     ;
 
     std::string insert_sql_str = "INSERT OR REPLACE INTO KVS (KEY, VALUE, TYPE) VALUES "
@@ -144,7 +143,7 @@ void kvsImpl::handle_store(std::string& key,
     }
 };
 
-boost::variant<boost::blank, Array, Object, bool, double, int, std::string> kvsImpl::handle_load(std::string& key) {
+std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string> kvsImpl::handle_load(std::string& key) {
     std::string select_sql_str = "SELECT KEY, VALUE, TYPE FROM KVS WHERE KEY = @key";
     sqlite3_stmt* select_statement;
     sqlite3_prepare_v2(db, select_sql_str.c_str(), select_sql_str.size(), &select_statement, NULL);
@@ -157,7 +156,7 @@ boost::variant<boost::blank, Array, Object, bool, double, int, std::string> kvsI
         return {};
     }
 
-    boost::variant<boost::blank, Array, Object, bool, double, int, std::string> value;
+    std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string> value;
 
     auto value_ptr = sqlite3_column_text(select_statement, 1);
     if (value_ptr != nullptr) {
diff --git a/modules/PersistentStore/main/kvsImpl.hpp b/modules/PersistentStore/main/kvsImpl.hpp
index 9bf59841d..c14a7cdf9 100644
--- a/modules/PersistentStore/main/kvsImpl.hpp
+++ b/modules/PersistentStore/main/kvsImpl.hpp
@@ -37,8 +37,8 @@ class kvsImpl : public kvsImplBase {
     // command handler functions (virtual)
     virtual void
     handle_store(std::string& key,
-                 boost::variant<boost::blank, Array, Object, bool, double, int, std::string>& value) override;
-    virtual boost::variant<boost::blank, Array, Object, bool, double, int, std::string>
+                 std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>& value) override;
+    virtual std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>
     handle_load(std::string& key) override;
     virtual void handle_delete(std::string& key) override;
     virtual bool handle_exists(std::string& key) override;
diff --git a/modules/PowermeterBSM/lib/transport.cpp b/modules/PowermeterBSM/lib/transport.cpp
index c27b70493..b908deb2f 100644
--- a/modules/PowermeterBSM/lib/transport.cpp
+++ b/modules/PowermeterBSM/lib/transport.cpp
@@ -110,9 +110,7 @@ transport::DataVector SerialCommHubTransport::fetch(protocol_related_types::Suns
 
         // make sure that returned vector is a int32 vector
         static_assert(
-            std::is_same<
-                int32_t,
-                decltype(types::serial_comm_hub_requests::Result::value)::this_type::value_type::value_type>::value);
+            std::is_same_v<int32_t, decltype(types::serial_comm_hub_requests::Result::value)::value_type::value_type>);
 
         union {
             int32_t val_32;
@@ -128,7 +126,7 @@ transport::DataVector SerialCommHubTransport::fetch(protocol_related_types::Suns
 
         transport::DataVector tmp{};
 
-        for (auto item : serial_com_hub_result.value.get()) {
+        for (auto item : serial_com_hub_result.value.value()) {
             swapit.val_32 = item;
             tmp.push_back(swapit.val_8.v2);
             tmp.push_back(swapit.val_8.v3);
@@ -156,12 +154,12 @@ bool SerialCommHubTransport::trigger_snapshot_generation(
 
     types::serial_comm_hub_requests::VectorUint16 trigger_create_snapshot_command{{0x0002}};
 
-    types::serial_comm_hub_requests::StatusCodeEnum write_result =
-        m_serial_hub.call_modbus_write_multiple_registers(m_unit_id, snapshot_trigger_register.val, trigger_create_snapshot_command);
+    types::serial_comm_hub_requests::StatusCodeEnum write_result = m_serial_hub.call_modbus_write_multiple_registers(
+        m_unit_id, snapshot_trigger_register.val, trigger_create_snapshot_command);
 
     if (not(types::serial_comm_hub_requests::StatusCodeEnum::Success == write_result))
         throw(""s + __PRETTY_FUNCTION__ + " SerialCommHub error : "s +
-              types::serial_comm_hub_requests::status_code_enum_to_string( write_result ) );
+              types::serial_comm_hub_requests::status_code_enum_to_string(write_result));
 
     std::size_t counter = 10;
 
@@ -173,7 +171,7 @@ bool SerialCommHubTransport::trigger_snapshot_generation(
         if (not serial_com_hub_result.value.has_value())
             throw std::runtime_error("no result from serial com hub!");
 
-        auto snapshot_generatrion_code = serial_com_hub_result.value.get();
+        auto snapshot_generatrion_code = serial_com_hub_result.value.value();
 
         if ((not snapshot_generatrion_code.empty()) and (snapshot_generatrion_code[0] == 0))
             return true;
diff --git a/modules/Setup/Setup.cpp b/modules/Setup/Setup.cpp
index 9300b8d50..8f8003a7b 100644
--- a/modules/Setup/Setup.cpp
+++ b/modules/Setup/Setup.cpp
@@ -235,10 +235,11 @@ void Setup::set_default_language(std::string language) {
 
 std::string Setup::get_default_language() {
     auto language = this->r_store->call_load("everest_localization_default_language");
-    if (language.which() == 0) {
+    // FIXME (aw): accessing the index of the autogenerated variant is dangerous, because the order is not guaranteed!
+    if (language.index() == 0) {
         return "unknown";
     }
-    return boost::get<std::string>(language);
+    return std::get<std::string>(language);
 }
 
 void Setup::set_current_language(const std::string& language) {
@@ -259,10 +260,11 @@ void Setup::set_mode(std::string mode) {
 
 std::string Setup::get_mode() {
     auto mode = this->r_store->call_load("everest_mode");
-    if (mode.which() == 0) {
+    // FIXME (aw): accessing the index of the autogenerated variant is dangerous, because the order is not guaranteed!
+    if (mode.index() == 0) {
         return "unknown";
     }
-    return boost::get<std::string>(mode);
+    return std::get<std::string>(mode);
 }
 
 void Setup::set_initialized(bool initialized) {
@@ -274,10 +276,11 @@ bool Setup::get_initialized() {
         return true;
     }
     auto initialized = this->r_store->call_load("everest_initialized");
-    if (initialized.which() == 0) {
+    // FIXME (aw): accessing the index of the autogenerated variant is dangerous, because the order is not guaranteed!
+    if (initialized.index() == 0) {
         return false;
     }
-    return boost::get<bool>(initialized);
+    return std::get<bool>(initialized);
 }
 
 void Setup::discover_network() {
diff --git a/modules/Store/main/kvsImpl.cpp b/modules/Store/main/kvsImpl.cpp
index c33c22b62..87e8ddd62 100644
--- a/modules/Store/main/kvsImpl.cpp
+++ b/modules/Store/main/kvsImpl.cpp
@@ -12,11 +12,11 @@ void kvsImpl::ready() {
 }
 
 void kvsImpl::handle_store(std::string& key,
-                           boost::variant<boost::blank, Array, Object, bool, double, int, std::string>& value) {
+                           std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>& value) {
     kvs[key] = value;
 };
 
-boost::variant<boost::blank, Array, Object, bool, double, int, std::string> kvsImpl::handle_load(std::string& key) {
+std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string> kvsImpl::handle_load(std::string& key) {
     return kvs[key];
 };
 
diff --git a/modules/Store/main/kvsImpl.hpp b/modules/Store/main/kvsImpl.hpp
index 67305d95a..640a4566a 100644
--- a/modules/Store/main/kvsImpl.hpp
+++ b/modules/Store/main/kvsImpl.hpp
@@ -35,8 +35,8 @@ class kvsImpl : public kvsImplBase {
     // command handler functions (virtual)
     virtual void
     handle_store(std::string& key,
-                 boost::variant<boost::blank, Array, Object, bool, double, int, std::string>& value) override;
-    virtual boost::variant<boost::blank, Array, Object, bool, double, int, std::string>
+                 std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>& value) override;
+    virtual std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>
     handle_load(std::string& key) override;
     virtual void handle_delete(std::string& key) override;
     virtual bool handle_exists(std::string& key) override;
@@ -53,7 +53,7 @@ class kvsImpl : public kvsImplBase {
     virtual void ready() override;
 
     // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
-    std::map<std::string, boost::variant<boost::blank, Array, Object, bool, double, int, std::string>> kvs{};
+    std::map<std::string, std::variant<std::nullptr_t, Array, Object, bool, double, int, std::string>> kvs{};
     // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
 };
 
diff --git a/modules/System/main/systemImpl.cpp b/modules/System/main/systemImpl.cpp
index 7d09467d1..c81129218 100644
--- a/modules/System/main/systemImpl.cpp
+++ b/modules/System/main/systemImpl.cpp
@@ -70,9 +70,9 @@ void systemImpl::standard_firmware_update(const types::system::FirmwareUpdateReq
         const std::vector<std::string> args = {constants.string(), firmware_update_request.location,
                                                firmware_file_path.string()};
         int32_t retries = 0;
-        const auto total_retries = firmware_update_request.retries.get_value_or(this->mod->config.DefaultRetries);
+        const auto total_retries = firmware_update_request.retries.value_or(this->mod->config.DefaultRetries);
         const auto retry_interval =
-            firmware_update_request.retry_interval_s.get_value_or(this->mod->config.DefaultRetryInterval);
+            firmware_update_request.retry_interval_s.value_or(this->mod->config.DefaultRetryInterval);
 
         auto firmware_status_enum = types::system::FirmwareUpdateStatusEnum::DownloadFailed;
         types::system::FirmwareUpdateStatus firmware_status;
@@ -186,11 +186,11 @@ void systemImpl::download_signed_firmware(const types::system::FirmwareUpdateReq
 
     const std::vector<std::string> download_args = {
         constants.string(), firmware_update_request.location, firmware_file_path.string(),
-        firmware_update_request.signature.get(), firmware_update_request.signing_certificate.get()};
+        firmware_update_request.signature.value(), firmware_update_request.signing_certificate.value()};
     int32_t retries = 0;
-    const auto total_retries = firmware_update_request.retries.get_value_or(this->mod->config.DefaultRetries);
+    const auto total_retries = firmware_update_request.retries.value_or(this->mod->config.DefaultRetries);
     const auto retry_interval =
-        firmware_update_request.retry_interval_s.get_value_or(this->mod->config.DefaultRetryInterval);
+        firmware_update_request.retry_interval_s.value_or(this->mod->config.DefaultRetryInterval);
 
     auto firmware_status_enum = types::system::FirmwareUpdateStatusEnum::DownloadFailed;
     types::system::FirmwareUpdateStatus firmware_status;
@@ -329,9 +329,9 @@ systemImpl::handle_upload_logs(types::system::UploadLogsRequest& upload_logs_req
                                          diagnostics_file_path.string()};
         bool uploaded = false;
         int32_t retries = 0;
-        const auto total_retries = upload_logs_request.retries.get_value_or(this->mod->config.DefaultRetries);
+        const auto total_retries = upload_logs_request.retries.value_or(this->mod->config.DefaultRetries);
         const auto retry_interval =
-            upload_logs_request.retry_interval_s.get_value_or(this->mod->config.DefaultRetryInterval);
+            upload_logs_request.retry_interval_s.value_or(this->mod->config.DefaultRetryInterval);
 
         types::system::LogStatus log_status;
         while (!uploaded && retries <= total_retries && !this->interrupt_log_upload) {