diff --git a/CMakeLists.txt b/CMakeLists.txt
index a15e719..56a2d91 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -119,6 +119,7 @@
 
 # add_definitions(-DBOOST_ASIO_ENABLE_HANDLER_TRACKING)
 add_definitions (-DBOOST_ASIO_DISABLE_THREADS)
+add_definitions (-DBOOST_BEAST_USE_STD_STRING_VIEW)
 add_definitions (-DBOOST_ERROR_CODE_HEADER_ONLY)
 add_definitions (-DBOOST_SYSTEM_NO_DEPRECATED)
 add_definitions (-DBOOST_ALL_NO_LIB)
diff --git a/crow/include/crow/http_connection.h b/crow/include/crow/http_connection.h
index f056f27..c02f4ec 100644
--- a/crow/include/crow/http_connection.h
+++ b/crow/include/crow/http_connection.h
@@ -474,7 +474,7 @@
                 // Compute the url parameters for the request
                 req->url = req->target();
                 std::size_t index = req->url.find("?");
-                if (index != boost::string_view::npos)
+                if (index != std::string_view::npos)
                 {
                     req->url = req->url.substr(0, index);
                 }
diff --git a/crow/include/crow/http_request.h b/crow/include/crow/http_request.h
index 7de618f..0ba0266 100644
--- a/crow/include/crow/http_request.h
+++ b/crow/include/crow/http_request.h
@@ -13,7 +13,7 @@
 struct Request
 {
     boost::beast::http::request<boost::beast::http::string_body>& req;
-    boost::string_view url{};
+    std::string_view url{};
     QueryString urlParams{};
     bool isSecure{false};
 
@@ -32,22 +32,22 @@
         return req.method();
     }
 
-    const boost::string_view getHeaderValue(boost::string_view key) const
+    const std::string_view getHeaderValue(std::string_view key) const
     {
         return req[key];
     }
 
-    const boost::string_view getHeaderValue(boost::beast::http::field key) const
+    const std::string_view getHeaderValue(boost::beast::http::field key) const
     {
         return req[key];
     }
 
-    const boost::string_view methodString() const
+    const std::string_view methodString() const
     {
         return req.method_string();
     }
 
-    const boost::string_view target() const
+    const std::string_view target() const
     {
         return req.target();
     }
diff --git a/crow/include/crow/http_response.h b/crow/include/crow/http_response.h
index 1deae34..093bd90 100644
--- a/crow/include/crow/http_response.h
+++ b/crow/include/crow/http_response.h
@@ -24,12 +24,12 @@
 
     nlohmann::json jsonValue;
 
-    void addHeader(const boost::string_view key, const boost::string_view value)
+    void addHeader(const std::string_view key, const std::string_view value)
     {
         stringResponse->set(key, value);
     }
 
-    void addHeader(boost::beast::http::field key, boost::string_view value)
+    void addHeader(boost::beast::http::field key, std::string_view value)
     {
         stringResponse->set(key, value);
     }
@@ -43,13 +43,12 @@
     {
     }
 
-    explicit Response(boost::string_view body_) :
-        stringResponse(response_type{})
+    explicit Response(std::string_view body_) : stringResponse(response_type{})
     {
         stringResponse->body() = std::string(body_);
     }
 
-    Response(boost::beast::http::status code, boost::string_view s) :
+    Response(boost::beast::http::status code, std::string_view s) :
         stringResponse(response_type{})
     {
         stringResponse->result(code);
@@ -94,7 +93,7 @@
         return stringResponse->result_int();
     }
 
-    boost::string_view reason()
+    std::string_view reason()
     {
         return stringResponse->reason();
     }
@@ -132,7 +131,7 @@
         completed = false;
     }
 
-    void write(boost::string_view body_part)
+    void write(std::string_view body_part)
     {
         stringResponse->body() += std::string(body_part);
     }
@@ -153,7 +152,7 @@
         }
     }
 
-    void end(boost::string_view body_part)
+    void end(std::string_view body_part)
     {
         write(body_part);
         end();
diff --git a/crow/include/crow/routing.h b/crow/include/crow/routing.h
index 7ba5171..746e115 100644
--- a/crow/include/crow/routing.h
+++ b/crow/include/crow/routing.h
@@ -689,7 +689,7 @@
     }
 
     std::pair<unsigned, RoutingParams>
-        find(const boost::string_view req_url, const Node* node = nullptr,
+        find(const std::string_view req_url, const Node* node = nullptr,
              unsigned pos = 0, RoutingParams* params = nullptr) const
     {
         RoutingParams empty;
diff --git a/crow/include/crow/utility.h b/crow/include/crow/utility.h
index 4bc7808..a07c041 100644
--- a/crow/include/crow/utility.h
+++ b/crow/include/crow/utility.h
@@ -571,7 +571,7 @@
 
 // TODO this is temporary and should be deleted once base64 is refactored out of
 // crow
-inline bool base64Decode(const boost::string_view input, std::string& output)
+inline bool base64Decode(const std::string_view input, std::string& output)
 {
     static const char nop = -1;
     // See note on encoding_data[] in above function
diff --git a/crow/include/crow/websocket.h b/crow/include/crow/websocket.h
index 6ce7e05..6901eb1 100644
--- a/crow/include/crow/websocket.h
+++ b/crow/include/crow/websocket.h
@@ -73,7 +73,7 @@
     {
         BMCWEB_LOG_DEBUG << "starting connection " << this;
 
-        boost::string_view protocol = req.getHeaderValue(
+        std::string_view protocol = req.getHeaderValue(
             boost::beast::http::field::sec_websocket_protocol);
 
         // Perform the websocket upgrade
diff --git a/include/http_utility.hpp b/include/http_utility.hpp
index 0f5bb8c..e2b1a11 100644
--- a/include/http_utility.hpp
+++ b/include/http_utility.hpp
@@ -5,7 +5,7 @@
 {
 inline bool requestPrefersHtml(const crow::Request& req)
 {
-    boost::string_view header = req.getHeaderValue("accept");
+    std::string_view header = req.getHeaderValue("accept");
     std::vector<std::string> encodings;
     // chrome currently sends 6 accepts headers, firefox sends 4.
     encodings.reserve(6);
@@ -25,7 +25,7 @@
     return false;
 }
 
-inline std::string urlEncode(const boost::string_view value)
+inline std::string urlEncode(const std::string_view value)
 {
     std::ostringstream escaped;
     escaped.fill('0');
diff --git a/include/pam_authenticate.hpp b/include/pam_authenticate.hpp
index 7f2a33c..f211a29 100644
--- a/include/pam_authenticate.hpp
+++ b/include/pam_authenticate.hpp
@@ -17,7 +17,7 @@
     char* appPass = reinterpret_cast<char*>(appdataPtr);
     size_t appPassSize = std::strlen(appPass);
     char* pass = reinterpret_cast<char*>(malloc(appPassSize + 1));
-    if (!pass)
+    if (pass == nullptr)
     {
         return PAM_AUTH_ERR;
     }
@@ -27,7 +27,7 @@
     *resp = reinterpret_cast<pam_response*>(
         calloc(numMsg, sizeof(struct pam_response)));
 
-    if (resp == NULL)
+    if (resp == nullptr)
     {
         return PAM_AUTH_ERR;
     }
@@ -47,8 +47,8 @@
     return PAM_SUCCESS;
 }
 
-inline bool pamAuthenticateUser(const boost::string_view username,
-                                const boost::string_view password)
+inline bool pamAuthenticateUser(const std::string_view username,
+                                const std::string_view password)
 {
     std::string userStr(username);
     std::string passStr(password);
diff --git a/include/sessions.hpp b/include/sessions.hpp
index 510f566..6bc1c99 100644
--- a/include/sessions.hpp
+++ b/include/sessions.hpp
@@ -102,7 +102,7 @@
 {
   public:
     std::shared_ptr<UserSession> generateUserSession(
-        const boost::string_view username,
+        const std::string_view username,
         PersistenceType persistence = PersistenceType::TIMEOUT)
     {
         // TODO(ed) find a secure way to not generate session identifiers if
@@ -148,7 +148,7 @@
     }
 
     std::shared_ptr<UserSession>
-        loginSessionByToken(const boost::string_view token)
+        loginSessionByToken(const std::string_view token)
     {
         applySessionTimeouts();
         auto sessionIt = authTokens.find(std::string(token));
@@ -161,7 +161,7 @@
         return userSession;
     }
 
-    std::shared_ptr<UserSession> getSessionByUid(const boost::string_view uid)
+    std::shared_ptr<UserSession> getSessionByUid(const std::string_view uid)
     {
         applySessionTimeouts();
         // TODO(Ed) this is inefficient
diff --git a/include/token_authorization_middleware.hpp b/include/token_authorization_middleware.hpp
index b186a5f..c5c6523 100644
--- a/include/token_authorization_middleware.hpp
+++ b/include/token_authorization_middleware.hpp
@@ -39,7 +39,7 @@
         }
         if (ctx.session == nullptr)
         {
-            boost::string_view authHeader = req.getHeaderValue("Authorization");
+            std::string_view authHeader = req.getHeaderValue("Authorization");
             if (!authHeader.empty())
             {
                 // Reject any kind of auth other than basic or token
@@ -104,12 +104,12 @@
 
   private:
     const std::shared_ptr<crow::persistent_data::UserSession>
-        performBasicAuth(boost::string_view auth_header) const
+        performBasicAuth(std::string_view auth_header) const
     {
         BMCWEB_LOG_DEBUG << "[AuthMiddleware] Basic authentication";
 
         std::string authData;
-        boost::string_view param = auth_header.substr(strlen("Basic "));
+        std::string_view param = auth_header.substr(strlen("Basic "));
         if (!crow::utility::base64Decode(param, authData))
         {
             return nullptr;
@@ -146,11 +146,11 @@
     }
 
     const std::shared_ptr<crow::persistent_data::UserSession>
-        performTokenAuth(boost::string_view auth_header) const
+        performTokenAuth(std::string_view auth_header) const
     {
         BMCWEB_LOG_DEBUG << "[AuthMiddleware] Token authentication";
 
-        boost::string_view token = auth_header.substr(strlen("Token "));
+        std::string_view token = auth_header.substr(strlen("Token "));
         auto session =
             persistent_data::SessionStore::getInstance().loginSessionByToken(
                 token);
@@ -162,7 +162,7 @@
     {
         BMCWEB_LOG_DEBUG << "[AuthMiddleware] X-Auth-Token authentication";
 
-        boost::string_view token = req.getHeaderValue("X-Auth-Token");
+        std::string_view token = req.getHeaderValue("X-Auth-Token");
         if (token.empty())
         {
             return nullptr;
@@ -178,7 +178,7 @@
     {
         BMCWEB_LOG_DEBUG << "[AuthMiddleware] Cookie authentication";
 
-        boost::string_view cookieValue = req.getHeaderValue("Cookie");
+        std::string_view cookieValue = req.getHeaderValue("Cookie");
         if (cookieValue.empty())
         {
             return nullptr;
@@ -195,7 +195,7 @@
         {
             endIndex = cookieValue.size();
         }
-        boost::string_view authKey =
+        std::string_view authKey =
             cookieValue.substr(startIndex, endIndex - startIndex);
 
         const std::shared_ptr<crow::persistent_data::UserSession> session =
@@ -209,7 +209,7 @@
         // RFC7231 defines methods that need csrf protection
         if (req.method() != "GET"_method)
         {
-            boost::string_view csrf = req.getHeaderValue("X-XSRF-TOKEN");
+            std::string_view csrf = req.getHeaderValue("X-XSRF-TOKEN");
             // Make sure both tokens are filled
             if (csrf.empty() || session->csrfToken.empty())
             {
@@ -274,9 +274,9 @@
     BMCWEB_ROUTE(app, "/login")
         .methods(
             "POST"_method)([&](const crow::Request& req, crow::Response& res) {
-            boost::string_view contentType = req.getHeaderValue("content-type");
-            boost::string_view username;
-            boost::string_view password;
+            std::string_view contentType = req.getHeaderValue("content-type");
+            std::string_view username;
+            std::string_view password;
 
             bool looksLikeIbm = false;
 
diff --git a/redfish-core/lib/log_services.hpp b/redfish-core/lib/log_services.hpp
index 3cff994..d15837d 100644
--- a/redfish-core/lib/log_services.hpp
+++ b/redfish-core/lib/log_services.hpp
@@ -39,8 +39,8 @@
 namespace fs = std::filesystem;
 
 static int getJournalMetadata(sd_journal *journal,
-                              const boost::string_view &field,
-                              boost::string_view &contents)
+                              const std::string_view &field,
+                              std::string_view &contents)
 {
     const char *data = nullptr;
     size_t length = 0;
@@ -52,18 +52,18 @@
     {
         return ret;
     }
-    contents = boost::string_view(data, length);
+    contents = std::string_view(data, length);
     // Only use the content after the "=" character.
     contents.remove_prefix(std::min(contents.find("=") + 1, contents.size()));
     return ret;
 }
 
 static int getJournalMetadata(sd_journal *journal,
-                              const boost::string_view &field, const int &base,
+                              const std::string_view &field, const int &base,
                               int &contents)
 {
     int ret = 0;
-    boost::string_view metadata;
+    std::string_view metadata;
     // Get the metadata from the requested field of the journal entry
     ret = getJournalMetadata(journal, field, metadata);
     if (ret < 0)
@@ -94,14 +94,14 @@
         strftime(entryTime, sizeof(entryTime), "%FT%T%z", loctime);
     }
     // Insert the ':' into the timezone
-    boost::string_view t1(entryTime);
-    boost::string_view t2(entryTime);
+    std::string_view t1(entryTime);
+    std::string_view t2(entryTime);
     if (t1.size() > 2 && t2.size() > 2)
     {
         t1.remove_suffix(2);
         t2.remove_prefix(t2.size() - 2);
     }
-    entryTimestamp = t1.to_string() + ":" + t2.to_string();
+    entryTimestamp = std::string(t1) + ":" + std::string(t2);
     return true;
 }
 
@@ -201,19 +201,19 @@
         return false;
     }
     // Convert the unique ID back to a timestamp to find the entry
-    boost::string_view tsStr(entryID);
+    std::string_view tsStr(entryID);
 
     auto underscorePos = tsStr.find("_");
     if (underscorePos != tsStr.npos)
     {
         // Timestamp has an index
         tsStr.remove_suffix(tsStr.size() - underscorePos);
-        boost::string_view indexStr(entryID);
+        std::string_view indexStr(entryID);
         indexStr.remove_prefix(underscorePos + 1);
         std::size_t pos;
         try
         {
-            index = std::stoul(indexStr.to_string(), &pos);
+            index = std::stoul(std::string(indexStr), &pos);
         }
         catch (std::invalid_argument)
         {
@@ -235,7 +235,7 @@
     std::size_t pos;
     try
     {
-        timestamp = std::stoull(tsStr.to_string(), &pos);
+        timestamp = std::stoull(std::string(tsStr), &pos);
     }
     catch (std::invalid_argument)
     {
@@ -342,14 +342,14 @@
 };
 
 static int fillEventLogEntryJson(const std::string &bmcLogEntryID,
-                                 const boost::string_view &messageID,
+                                 const std::string_view &messageID,
                                  sd_journal *journal,
                                  nlohmann::json &bmcLogEntryJson)
 {
     // Get the Log Entry contents
     int ret = 0;
 
-    boost::string_view msg;
+    std::string_view msg;
     ret = getJournalMetadata(journal, "MESSAGE", msg);
     if (ret < 0)
     {
@@ -373,8 +373,8 @@
     std::vector<std::string> messageArgs;
     SD_JOURNAL_FOREACH_DATA(journal, data, length)
     {
-        boost::string_view field(static_cast<const char *>(data), length);
-        if (field.starts_with("REDFISH_MESSAGE_ARG_"))
+        std::string_view field(static_cast<const char *>(data), length);
+        if (boost::starts_with(field, "REDFISH_MESSAGE_ARG_"))
         {
             // Get the Arg number from the field name
             field.remove_prefix(sizeof("REDFISH_MESSAGE_ARG_") - 1);
@@ -394,7 +394,7 @@
             {
                 messageArgs.resize(argNum);
             }
-            messageArgs[argNum - 1] = field.to_string();
+            messageArgs[argNum - 1] = std::string(field);
         }
     }
 
@@ -487,7 +487,7 @@
         {
             // Look for only journal entries that contain a REDFISH_MESSAGE_ID
             // field
-            boost::string_view messageID;
+            std::string_view messageID;
             ret = getJournalMetadata(journal.get(), "REDFISH_MESSAGE_ID",
                                      messageID);
             if (ret < 0)
@@ -590,7 +590,7 @@
         }
 
         // only use journal entries that contain a REDFISH_MESSAGE_ID field
-        boost::string_view messageID;
+        std::string_view messageID;
         ret =
             getJournalMetadata(journal.get(), "REDFISH_MESSAGE_ID", messageID);
         if (ret < 0)
@@ -698,7 +698,7 @@
     // Get the Log Entry contents
     int ret = 0;
 
-    boost::string_view msg;
+    std::string_view msg;
     ret = getJournalMetadata(journal, "MESSAGE", msg);
     if (ret < 0)
     {