diff --git a/src/replica/AddReplicaQservMgtRequest.cc b/src/replica/AddReplicaQservMgtRequest.cc
index c640380fd..3132769b2 100644
--- a/src/replica/AddReplicaQservMgtRequest.cc
+++ b/src/replica/AddReplicaQservMgtRequest.cc
@@ -50,7 +50,7 @@ AddReplicaQservMgtRequest::AddReplicaQservMgtRequest(shared_ptr<ServiceProvider>
                                                      string const& worker, unsigned int chunk,
                                                      vector<string> const& databases,
                                                      AddReplicaQservMgtRequest::CallbackType const& onFinish)
-        : QservMgtRequest(serviceProvider, "QSERV_ADD_REPLICA", worker),
+        : QservWorkerMgtRequest(serviceProvider, "QSERV_ADD_REPLICA", worker),
           _chunk(chunk),
           _databases(databases),
           _onFinish(onFinish) {}
diff --git a/src/replica/AddReplicaQservMgtRequest.h b/src/replica/AddReplicaQservMgtRequest.h
index 7672d8d5a..80fa6caad 100644
--- a/src/replica/AddReplicaQservMgtRequest.h
+++ b/src/replica/AddReplicaQservMgtRequest.h
@@ -32,7 +32,7 @@
 #include "nlohmann/json.hpp"
 
 // Qserv headers
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 
 namespace lsst::qserv::replica {
 class ServiceProvider;
@@ -46,7 +46,7 @@ namespace lsst::qserv::replica {
  * Class AddReplicaQservMgtRequest implements a request notifying Qserv workers
  * on new chunks added to the database.
  */
-class AddReplicaQservMgtRequest : public QservMgtRequest {
+class AddReplicaQservMgtRequest : public QservWorkerMgtRequest {
 public:
     typedef std::shared_ptr<AddReplicaQservMgtRequest> Ptr;
 
@@ -57,7 +57,7 @@ class AddReplicaQservMgtRequest : public QservMgtRequest {
     AddReplicaQservMgtRequest(AddReplicaQservMgtRequest const&) = delete;
     AddReplicaQservMgtRequest& operator=(AddReplicaQservMgtRequest const&) = delete;
 
-    virtual ~AddReplicaQservMgtRequest() final = default;
+    virtual ~AddReplicaQservMgtRequest() override = default;
 
     /**
      * Static factory method is needed to prevent issues with the lifespan
@@ -83,14 +83,14 @@ class AddReplicaQservMgtRequest : public QservMgtRequest {
     std::vector<std::string> const& databases() const { return _databases; }
 
     /// @see QservMgtRequest::extendedPersistentState()
-    virtual std::list<std::pair<std::string, std::string>> extendedPersistentState() const final;
+    virtual std::list<std::pair<std::string, std::string>> extendedPersistentState() const override;
 
 protected:
     /// @see QservMgtRequest::createHttpReqImpl
-    virtual void createHttpReqImpl(replica::Lock const& lock) final;
+    virtual void createHttpReqImpl(replica::Lock const& lock) override;
 
     /// @see QservMgtRequest::notify
-    virtual void notify(replica::Lock const& lock) final;
+    virtual void notify(replica::Lock const& lock) override;
 
 private:
     /// @see AddReplicaQservMgtRequest::create()
diff --git a/src/replica/CMakeLists.txt b/src/replica/CMakeLists.txt
index 63bd9960a..9565e0d91 100644
--- a/src/replica/CMakeLists.txt
+++ b/src/replica/CMakeLists.txt
@@ -132,12 +132,14 @@ target_sources(replica PRIVATE
     PurgeApp.cc
     PurgeJob.cc
     QhttpTestApp.cc
+    QservCzarMgtRequest.cc
     QservGetReplicasJob.cc
     QservMgtRequest.cc
     QservMgtServices.cc
     QservStatusJob.cc
     QservSyncJob.cc
     QservWorkerApp.cc
+    QservWorkerMgtRequest.cc
     QservWorkerPingApp.cc
     RebalanceApp.cc
     RebalanceJob.cc
diff --git a/src/replica/DatabaseServices.h b/src/replica/DatabaseServices.h
index 28de9de9d..1727f7ecc 100644
--- a/src/replica/DatabaseServices.h
+++ b/src/replica/DatabaseServices.h
@@ -48,7 +48,7 @@ namespace lsst::qserv::replica {
 class Configuration;
 class ControllerIdentity;
 class NamedMutexRegistry;
-class QservMgtRequest;
+class QservWorkerMgtRequest;
 class Performance;
 class Request;
 }  // namespace lsst::qserv::replica
@@ -423,17 +423,17 @@ class DatabaseServices : public std::enable_shared_from_this<DatabaseServices> {
     virtual void updateHeartbeatTime(Job const& job) = 0;
 
     /**
-     * Save the state of the QservMgtRequest. This operation can be called many times for
-     * a particular instance of the QservMgtRequest.
+     * Save the state of the QservWorkerMgtRequest. This operation can be called many times for
+     * a particular instance of the QservWorkerMgtRequest.
      *
      * The Performance object is explicitly passed as a parameter to avoid
      * making a blocked call back to the request which may create a deadlock.
      *
-     * @param request a reference to a QservMgtRequest object
+     * @param request a reference to a QservWorkerMgtRequest object
      * @param performance a reference to a Performance object
      * @param serverError a server error message (if any)
      */
-    virtual void saveState(QservMgtRequest const& request, Performance const& performance,
+    virtual void saveState(QservWorkerMgtRequest const& request, Performance const& performance,
                            std::string const& serverError) = 0;
 
     /**
diff --git a/src/replica/DatabaseServicesMySQL.cc b/src/replica/DatabaseServicesMySQL.cc
index ad1dfa5b9..6f2c2145d 100644
--- a/src/replica/DatabaseServicesMySQL.cc
+++ b/src/replica/DatabaseServicesMySQL.cc
@@ -39,7 +39,7 @@
 #include "replica/DatabaseMySQLUtils.h"
 #include "replica/Job.h"
 #include "replica/NamedMutexRegistry.h"
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 #include "replica/ReplicaInfo.h"
 #include "replica/Request.h"
 #include "replica/SemanticMaps.h"
@@ -159,10 +159,10 @@ void DatabaseServicesMySQL::updateHeartbeatTime(Job const& job) {
     LOGS(_log, LOG_LVL_DEBUG, context + "** DONE **");
 }
 
-void DatabaseServicesMySQL::saveState(QservMgtRequest const& request, Performance const& performance,
+void DatabaseServicesMySQL::saveState(QservWorkerMgtRequest const& request, Performance const& performance,
                                       string const& serverError) {
     string const context =
-            "DatabaseServicesMySQL::" + string(__func__) + "[QservMgtRequest::" + request.type() + "] ";
+            "DatabaseServicesMySQL::" + string(__func__) + "[QservWorkerMgtRequest::" + request.type() + "] ";
     LOGS(_log, LOG_LVL_DEBUG, context);
 
     // Requests which haven't started yet or the ones which aren't associated
@@ -181,14 +181,14 @@ void DatabaseServicesMySQL::saveState(QservMgtRequest const& request, Performanc
     replica::Lock lock(_mtx, context);
 
     // The algorithm will first try the INSERT query into the base table.
-    // If a row with the same primary key (QservMgtRequest id) already exists in the table
+    // If a row with the same primary key (id) already exists in the table
     // then the UPDATE query will be executed.
     try {
         auto const insert = [&](decltype(_conn) conn) {
             string const query =
                     _g.insert("request", request.id(), request.jobId(), request.type(), request.workerName(),
-                              0, QservMgtRequest::state2string(request.state()),
-                              QservMgtRequest::state2string(request.extendedState()), serverError,
+                              0, QservWorkerMgtRequest::state2string(request.state()),
+                              QservWorkerMgtRequest::state2string(request.extendedState()), serverError,
                               performance.c_create_time, performance.c_start_time, performance.w_receive_time,
                               performance.w_start_time, performance.w_finish_time, performance.c_finish_time);
             conn->execute(query);
@@ -201,8 +201,10 @@ void DatabaseServicesMySQL::saveState(QservMgtRequest const& request, Performanc
         };
         auto const update = [&](decltype(_conn) conn) {
             string const query =
-                    _g.update("request", make_pair("state", QservMgtRequest::state2string(request.state())),
-                              make_pair("ext_state", QservMgtRequest::state2string(request.extendedState())),
+                    _g.update("request",
+                              make_pair("state", QservWorkerMgtRequest::state2string(request.state())),
+                              make_pair("ext_state",
+                                        QservWorkerMgtRequest::state2string(request.extendedState())),
                               make_pair("server_status", serverError),
                               make_pair("c_create_time", performance.c_create_time),
                               make_pair("c_start_time", performance.c_start_time),
@@ -242,7 +244,7 @@ void DatabaseServicesMySQL::saveState(Request const& request, Performance const&
     replica::Lock lock(_mtx, context);
 
     // The algorithm will first try the INSERT query into the base table.
-    // If a row with the same primary key (QservMgtRequest id) already exists in the table
+    // If a row with the same primary key (request id) already exists in the table
     // then the UPDATE query will be executed.
     try {
         auto const insert = [&](decltype(_conn) conn) {
diff --git a/src/replica/DatabaseServicesMySQL.h b/src/replica/DatabaseServicesMySQL.h
index f09390016..5bfc20cba 100644
--- a/src/replica/DatabaseServicesMySQL.h
+++ b/src/replica/DatabaseServicesMySQL.h
@@ -71,7 +71,7 @@ class DatabaseServicesMySQL : public DatabaseServices {
 
     void updateHeartbeatTime(Job const& job) final;
 
-    void saveState(QservMgtRequest const& request, Performance const& performance,
+    void saveState(QservWorkerMgtRequest const& request, Performance const& performance,
                    std::string const& serverError) final;
 
     void saveState(Request const& request, Performance const& performance) final;
diff --git a/src/replica/DatabaseServicesPool.cc b/src/replica/DatabaseServicesPool.cc
index 0b4b2b044..949392580 100644
--- a/src/replica/DatabaseServicesPool.cc
+++ b/src/replica/DatabaseServicesPool.cc
@@ -102,7 +102,7 @@ void DatabaseServicesPool::updateHeartbeatTime(Job const& job) {
     service()->updateHeartbeatTime(job);
 }
 
-void DatabaseServicesPool::saveState(QservMgtRequest const& request, Performance const& performance,
+void DatabaseServicesPool::saveState(QservWorkerMgtRequest const& request, Performance const& performance,
                                      string const& serverError) {
     ServiceAllocator service(shared_from_base<DatabaseServicesPool>());
     service()->saveState(request, performance, serverError);
diff --git a/src/replica/DatabaseServicesPool.h b/src/replica/DatabaseServicesPool.h
index 034af84c1..4817e236f 100644
--- a/src/replica/DatabaseServicesPool.h
+++ b/src/replica/DatabaseServicesPool.h
@@ -74,7 +74,7 @@ class DatabaseServicesPool : public DatabaseServices {
 
     void updateHeartbeatTime(Job const& job) final;
 
-    void saveState(QservMgtRequest const& request, Performance const& performance,
+    void saveState(QservWorkerMgtRequest const& request, Performance const& performance,
                    std::string const& serverError) final;
 
     void saveState(Request const& request, Performance const& performance) final;
diff --git a/src/replica/GetConfigQservMgtRequest.cc b/src/replica/GetConfigQservMgtRequest.cc
index 1c43deb02..d321924f5 100644
--- a/src/replica/GetConfigQservMgtRequest.cc
+++ b/src/replica/GetConfigQservMgtRequest.cc
@@ -45,7 +45,7 @@ shared_ptr<GetConfigQservMgtRequest> GetConfigQservMgtRequest::create(
 GetConfigQservMgtRequest::GetConfigQservMgtRequest(shared_ptr<ServiceProvider> const& serviceProvider,
                                                    string const& worker,
                                                    GetConfigQservMgtRequest::CallbackType const& onFinish)
-        : QservMgtRequest(serviceProvider, "QSERV_GET_DATABASE_STATUS", worker), _onFinish(onFinish) {}
+        : QservWorkerMgtRequest(serviceProvider, "QSERV_GET_DATABASE_STATUS", worker), _onFinish(onFinish) {}
 
 void GetConfigQservMgtRequest::createHttpReqImpl(replica::Lock const& lock) {
     string const service = "/config";
diff --git a/src/replica/GetConfigQservMgtRequest.h b/src/replica/GetConfigQservMgtRequest.h
index 6877b723b..42e86fad0 100644
--- a/src/replica/GetConfigQservMgtRequest.h
+++ b/src/replica/GetConfigQservMgtRequest.h
@@ -26,7 +26,7 @@
 #include <string>
 
 // Qserv headers
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 
 namespace lsst::qserv::replica {
 class ServiceProvider;
@@ -39,7 +39,7 @@ namespace lsst::qserv::replica {
  * Class GetConfigQservMgtRequest is a request for obtaining various info
  * on the database service of the Qserv worker.
  */
-class GetConfigQservMgtRequest : public QservMgtRequest {
+class GetConfigQservMgtRequest : public QservWorkerMgtRequest {
 public:
     typedef std::shared_ptr<GetConfigQservMgtRequest> Ptr;
 
@@ -50,7 +50,7 @@ class GetConfigQservMgtRequest : public QservMgtRequest {
     GetConfigQservMgtRequest(GetConfigQservMgtRequest const&) = delete;
     GetConfigQservMgtRequest& operator=(GetConfigQservMgtRequest const&) = delete;
 
-    virtual ~GetConfigQservMgtRequest() final = default;
+    virtual ~GetConfigQservMgtRequest() override = default;
 
     /**
      * Static factory method is needed to prevent issues with the lifespan
@@ -68,10 +68,10 @@ class GetConfigQservMgtRequest : public QservMgtRequest {
 
 protected:
     /// @see QservMgtRequest::createHttpReqImpl()
-    virtual void createHttpReqImpl(replica::Lock const& lock) final;
+    virtual void createHttpReqImpl(replica::Lock const& lock) override;
 
     /// @see QservMgtRequest::notify()
-    virtual void notify(replica::Lock const& lock) final;
+    virtual void notify(replica::Lock const& lock) override;
 
 private:
     /// @see GetConfigQservMgtRequest::create()
diff --git a/src/replica/GetDbStatusQservMgtRequest.cc b/src/replica/GetDbStatusQservMgtRequest.cc
index ee6987ea7..173862e45 100644
--- a/src/replica/GetDbStatusQservMgtRequest.cc
+++ b/src/replica/GetDbStatusQservMgtRequest.cc
@@ -45,7 +45,7 @@ shared_ptr<GetDbStatusQservMgtRequest> GetDbStatusQservMgtRequest::create(
 GetDbStatusQservMgtRequest::GetDbStatusQservMgtRequest(
         shared_ptr<ServiceProvider> const& serviceProvider, string const& worker,
         GetDbStatusQservMgtRequest::CallbackType const& onFinish)
-        : QservMgtRequest(serviceProvider, "QSERV_GET_DATABASE_STATUS", worker), _onFinish(onFinish) {}
+        : QservWorkerMgtRequest(serviceProvider, "QSERV_GET_DATABASE_STATUS", worker), _onFinish(onFinish) {}
 
 void GetDbStatusQservMgtRequest::createHttpReqImpl(replica::Lock const& lock) {
     string const service = "/mysql";
diff --git a/src/replica/GetDbStatusQservMgtRequest.h b/src/replica/GetDbStatusQservMgtRequest.h
index cf9c04fca..c005eedf3 100644
--- a/src/replica/GetDbStatusQservMgtRequest.h
+++ b/src/replica/GetDbStatusQservMgtRequest.h
@@ -26,7 +26,7 @@
 #include <string>
 
 // Qserv headers
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 
 namespace lsst::qserv::replica {
 class ServiceProvider;
@@ -39,7 +39,7 @@ namespace lsst::qserv::replica {
  * Class GetDbStatusQservMgtRequest is a request for obtaining various info
  * on the database service of the Qserv worker.
  */
-class GetDbStatusQservMgtRequest : public QservMgtRequest {
+class GetDbStatusQservMgtRequest : public QservWorkerMgtRequest {
 public:
     typedef std::shared_ptr<GetDbStatusQservMgtRequest> Ptr;
 
@@ -50,7 +50,7 @@ class GetDbStatusQservMgtRequest : public QservMgtRequest {
     GetDbStatusQservMgtRequest(GetDbStatusQservMgtRequest const&) = delete;
     GetDbStatusQservMgtRequest& operator=(GetDbStatusQservMgtRequest const&) = delete;
 
-    virtual ~GetDbStatusQservMgtRequest() final = default;
+    virtual ~GetDbStatusQservMgtRequest() override = default;
 
     /**
      * Static factory method is needed to prevent issues with the lifespan
@@ -68,10 +68,10 @@ class GetDbStatusQservMgtRequest : public QservMgtRequest {
 
 protected:
     /// @see QservMgtRequest::createHttpReqImpl()
-    virtual void createHttpReqImpl(replica::Lock const& lock) final;
+    virtual void createHttpReqImpl(replica::Lock const& lock) override;
 
     /// @see QservMgtRequest::notify()
-    virtual void notify(replica::Lock const& lock) final;
+    virtual void notify(replica::Lock const& lock) override;
 
 private:
     /// @see GetDbStatusQservMgtRequest::create()
diff --git a/src/replica/GetReplicasQservMgtRequest.cc b/src/replica/GetReplicasQservMgtRequest.cc
index 0a1e42298..efbea2d30 100644
--- a/src/replica/GetReplicasQservMgtRequest.cc
+++ b/src/replica/GetReplicasQservMgtRequest.cc
@@ -55,7 +55,7 @@ GetReplicasQservMgtRequest::Ptr GetReplicasQservMgtRequest::create(
 GetReplicasQservMgtRequest::GetReplicasQservMgtRequest(
         ServiceProvider::Ptr const& serviceProvider, string const& worker, string const& databaseFamily,
         bool inUseOnly, GetReplicasQservMgtRequest::CallbackType const& onFinish)
-        : QservMgtRequest(serviceProvider, "QSERV_GET_REPLICAS", worker),
+        : QservWorkerMgtRequest(serviceProvider, "QSERV_GET_REPLICAS", worker),
           _databaseFamily(databaseFamily),
           _inUseOnly(inUseOnly),
           _onFinish(onFinish) {}
diff --git a/src/replica/GetReplicasQservMgtRequest.h b/src/replica/GetReplicasQservMgtRequest.h
index f98063a13..4b4e71db6 100644
--- a/src/replica/GetReplicasQservMgtRequest.h
+++ b/src/replica/GetReplicasQservMgtRequest.h
@@ -31,7 +31,7 @@
 #include "nlohmann/json.hpp"
 
 // Qserv headers
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 #include "replica/ReplicaInfo.h"
 
 namespace lsst::qserv::replica {
@@ -45,7 +45,7 @@ namespace lsst::qserv::replica {
  * Class GetReplicasQservMgtRequest implements a request retrieving a list of
  * replicas known to Qserv workers.
  */
-class GetReplicasQservMgtRequest : public QservMgtRequest {
+class GetReplicasQservMgtRequest : public QservWorkerMgtRequest {
 public:
     typedef std::shared_ptr<GetReplicasQservMgtRequest> Ptr;
 
@@ -56,7 +56,7 @@ class GetReplicasQservMgtRequest : public QservMgtRequest {
     GetReplicasQservMgtRequest(GetReplicasQservMgtRequest const&) = delete;
     GetReplicasQservMgtRequest& operator=(GetReplicasQservMgtRequest const&) = delete;
 
-    virtual ~GetReplicasQservMgtRequest() final = default;
+    virtual ~GetReplicasQservMgtRequest() override = default;
 
     /**
      * Static factory method is needed to prevent issues with the lifespan
@@ -93,14 +93,14 @@ class GetReplicasQservMgtRequest : public QservMgtRequest {
 
 protected:
     /// @see QservMgtRequest::createHttpReqImpl()
-    virtual void createHttpReqImpl(replica::Lock const& lock) final;
+    virtual void createHttpReqImpl(replica::Lock const& lock) override;
 
     /// @see QservMgtRequest::dataReady()
     virtual QservMgtRequest::ExtendedState dataReady(replica::Lock const& lock,
-                                                     nlohmann::json const& data) final;
+                                                     nlohmann::json const& data) override;
 
     /// @see QservMgtRequest::notify
-    virtual void notify(replica::Lock const& lock) final;
+    virtual void notify(replica::Lock const& lock) override;
 
 private:
     /// @see GetReplicasQservMgtRequest::create()
diff --git a/src/replica/GetResultFilesQservMgtRequest.cc b/src/replica/GetResultFilesQservMgtRequest.cc
index 8a8ad0af9..7659f1633 100644
--- a/src/replica/GetResultFilesQservMgtRequest.cc
+++ b/src/replica/GetResultFilesQservMgtRequest.cc
@@ -50,7 +50,7 @@ GetResultFilesQservMgtRequest::GetResultFilesQservMgtRequest(
         shared_ptr<ServiceProvider> const& serviceProvider, string const& worker,
         vector<QueryId> const& queryIds, unsigned int maxFiles,
         GetResultFilesQservMgtRequest::CallbackType const& onFinish)
-        : QservMgtRequest(serviceProvider, "QSERV_GET_RESULT_FILES", worker),
+        : QservWorkerMgtRequest(serviceProvider, "QSERV_GET_RESULT_FILES", worker),
           _queryIds(queryIds),
           _maxFiles(maxFiles),
           _onFinish(onFinish) {}
diff --git a/src/replica/GetResultFilesQservMgtRequest.h b/src/replica/GetResultFilesQservMgtRequest.h
index c1131a4b6..fedee1086 100644
--- a/src/replica/GetResultFilesQservMgtRequest.h
+++ b/src/replica/GetResultFilesQservMgtRequest.h
@@ -28,7 +28,7 @@
 
 // Qserv headers
 #include "global/intTypes.h"
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 
 namespace lsst::qserv::replica {
 class ServiceProvider;
@@ -41,7 +41,7 @@ namespace lsst::qserv::replica {
  * Class GetResultFilesQservMgtRequest is a request for obtaining info
  * on the partial result files from the Qserv worker.
  */
-class GetResultFilesQservMgtRequest : public QservMgtRequest {
+class GetResultFilesQservMgtRequest : public QservWorkerMgtRequest {
 public:
     typedef std::shared_ptr<GetResultFilesQservMgtRequest> Ptr;
 
@@ -52,7 +52,7 @@ class GetResultFilesQservMgtRequest : public QservMgtRequest {
     GetResultFilesQservMgtRequest(GetResultFilesQservMgtRequest const&) = delete;
     GetResultFilesQservMgtRequest& operator=(GetResultFilesQservMgtRequest const&) = delete;
 
-    virtual ~GetResultFilesQservMgtRequest() final = default;
+    virtual ~GetResultFilesQservMgtRequest() override = default;
 
     /**
      * Static factory method is needed to prevent issues with the lifespan
@@ -75,10 +75,10 @@ class GetResultFilesQservMgtRequest : public QservMgtRequest {
 
 protected:
     /// @see QservMgtRequest::createHttpReqImpl()
-    virtual void createHttpReqImpl(replica::Lock const& lock) final;
+    virtual void createHttpReqImpl(replica::Lock const& lock) override;
 
     /// @see QservMgtRequest::notify()
-    virtual void notify(replica::Lock const& lock) final;
+    virtual void notify(replica::Lock const& lock) override;
 
 private:
     /// @see GetResultFilesQservMgtRequest::create()
diff --git a/src/replica/GetStatusQservMgtRequest.cc b/src/replica/GetStatusQservMgtRequest.cc
index a47a28a00..c56cadebc 100644
--- a/src/replica/GetStatusQservMgtRequest.cc
+++ b/src/replica/GetStatusQservMgtRequest.cc
@@ -62,7 +62,7 @@ GetStatusQservMgtRequest::GetStatusQservMgtRequest(shared_ptr<ServiceProvider> c
                                                    string const& worker,
                                                    wbase::TaskSelector const& taskSelector,
                                                    GetStatusQservMgtRequest::CallbackType const& onFinish)
-        : QservMgtRequest(serviceProvider, "QSERV_GET_STATUS", worker),
+        : QservWorkerMgtRequest(serviceProvider, "QSERV_GET_STATUS", worker),
           _taskSelector(taskSelector),
           _onFinish(onFinish) {}
 
diff --git a/src/replica/GetStatusQservMgtRequest.h b/src/replica/GetStatusQservMgtRequest.h
index 8c19d530e..35281cf90 100644
--- a/src/replica/GetStatusQservMgtRequest.h
+++ b/src/replica/GetStatusQservMgtRequest.h
@@ -26,7 +26,7 @@
 #include <string>
 
 // Qserv headers
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 #include "wbase/TaskState.h"
 
 namespace lsst::qserv::replica {
@@ -51,7 +51,7 @@ std::string taskSelectorToHttpQuery(wbase::TaskSelector const& taskSelector);
  * Class GetStatusQservMgtRequest is a request for obtaining various info
  * (status, counters, monitoring) reported the Qserv workers.
  */
-class GetStatusQservMgtRequest : public QservMgtRequest {
+class GetStatusQservMgtRequest : public QservWorkerMgtRequest {
 public:
     typedef std::shared_ptr<GetStatusQservMgtRequest> Ptr;
 
@@ -62,7 +62,7 @@ class GetStatusQservMgtRequest : public QservMgtRequest {
     GetStatusQservMgtRequest(GetStatusQservMgtRequest const&) = delete;
     GetStatusQservMgtRequest& operator=(GetStatusQservMgtRequest const&) = delete;
 
-    virtual ~GetStatusQservMgtRequest() final = default;
+    virtual ~GetStatusQservMgtRequest() override = default;
 
     /**
      * Static factory method is needed to prevent issues with the lifespan
@@ -82,10 +82,10 @@ class GetStatusQservMgtRequest : public QservMgtRequest {
 
 protected:
     /// @see QservMgtRequest::createHttpReqImpl()
-    virtual void createHttpReqImpl(replica::Lock const& lock) final;
+    virtual void createHttpReqImpl(replica::Lock const& lock) override;
 
     /// @see QservMgtRequest::notify()
-    virtual void notify(replica::Lock const& lock) final;
+    virtual void notify(replica::Lock const& lock) override;
 
 private:
     /// @see GetStatusQservMgtRequest::create()
diff --git a/src/replica/HttpQservMonitorModule.cc b/src/replica/HttpQservMonitorModule.cc
index cb706a46c..d91bee979 100644
--- a/src/replica/HttpQservMonitorModule.cc
+++ b/src/replica/HttpQservMonitorModule.cc
@@ -137,7 +137,6 @@ void HttpQservMonitorModule::_throwIfNotSucceeded(string const& func,
                                                   shared_ptr<QservMgtRequest> const& request) {
     if (request->extendedState() == QservMgtRequest::ExtendedState::SUCCESS) return;
     string const msg = "request id: " + request->id() + " of type: " + request->type() +
-                       " sent to worker: " + request->workerName() +
                        " failed, error: " + QservMgtRequest::state2string(request->extendedState());
     throw http::Error(func, msg);
 }
diff --git a/src/replica/QservCzarMgtRequest.cc b/src/replica/QservCzarMgtRequest.cc
new file mode 100644
index 000000000..ac3d61850
--- /dev/null
+++ b/src/replica/QservCzarMgtRequest.cc
@@ -0,0 +1,53 @@
+/*
+ * LSST Data Management System
+ *
+ * This product includes software developed by the
+ * LSST Project (http://www.lsst.org/).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the LSST License Statement and
+ * the GNU General Public License along with this program.  If not,
+ * see <http://www.lsstcorp.org/LegalNotices/>.
+ */
+
+// Class header
+#include "replica/QservCzarMgtRequest.h"
+
+// System headers
+#include <stdexcept>
+
+// Qserv headers
+#include "replica/Configuration.h"
+#include "replica/ServiceProvider.h"
+
+using namespace std;
+
+namespace lsst::qserv::replica {
+
+QservCzarMgtRequest::QservCzarMgtRequest(ServiceProvider::Ptr const& serviceProvider, string const& type,
+                                         string const& czarName)
+        : QservMgtRequest(serviceProvider, type, "czar", czarName), _czarName(czarName) {
+    if (!serviceProvider->config()->isKnownWorker(_czarName)) {
+        throw invalid_argument("QservCzarMgtRequest::" + string(__func__) + " unknown Czar: '" + _czarName +
+                               "'.");
+    }
+}
+
+http::AsyncReq::GetHostPort QservCzarMgtRequest::getHostPortTracker() const {
+    return [config = serviceProvider()->config(),
+            czarName = _czarName](http::AsyncReq::HostPort const&) -> http::AsyncReq::HostPort {
+        auto const czar = config->czar(czarName);
+        return http::AsyncReq::HostPort{czar.host.addr, czar.port};
+    };
+}
+
+}  // namespace lsst::qserv::replica
diff --git a/src/replica/QservCzarMgtRequest.h b/src/replica/QservCzarMgtRequest.h
new file mode 100644
index 000000000..3be06fd15
--- /dev/null
+++ b/src/replica/QservCzarMgtRequest.h
@@ -0,0 +1,74 @@
+/*
+ * LSST Data Management System
+ *
+ * This product includes software developed by the
+ * LSST Project (http://www.lsst.org/).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the LSST License Statement and
+ * the GNU General Public License along with this program.  If not,
+ * see <http://www.lsstcorp.org/LegalNotices/>.
+ */
+#ifndef LSST_QSERV_REPLICA_QSERVCZARMGTREQUEST_H
+#define LSST_QSERV_REPLICA_QSERVCZARMGTREQUEST_H
+
+// System headers
+#include <memory>
+#include <string>
+
+// Qserv headers
+#include "http/AsyncReq.h"
+#include "replica/QservMgtRequest.h"
+
+// Forward declarations
+namespace lsst::qserv::replica {
+class ServiceProvider;
+}  // namespace lsst::qserv::replica
+
+// This header declarations
+namespace lsst::qserv::replica {
+
+/**
+ * @brief QservCzarMgtRequest is a base class for a family of the Qserv Czar
+ *   management requests within the master server.
+ */
+class QservCzarMgtRequest : public QservMgtRequest {
+public:
+    QservCzarMgtRequest() = delete;
+    QservCzarMgtRequest(QservCzarMgtRequest const&) = delete;
+    QservCzarMgtRequest& operator=(QservCzarMgtRequest const&) = delete;
+
+    virtual ~QservCzarMgtRequest() override = default;
+
+    /// @return name of a Czar
+    std::string const& czarName() const { return _czarName; }
+
+protected:
+    /**
+     * @brief Construct the request with the pointer to the services provider.
+     * @param serviceProvider Is required to access configuration services.
+     * @param type The type name of he request (used for debugging and error reporting).
+     * @param czarName The name of the Qserv Czar.
+     */
+    QservCzarMgtRequest(std::shared_ptr<ServiceProvider> const& serviceProvider, std::string const& type,
+                        std::string const& czarName);
+
+    /// @return The callback function for tracking connection parameters of the Czar.
+    virtual http::AsyncReq::GetHostPort getHostPortTracker() const override;
+
+private:
+    std::string const _czarName;
+};
+
+}  // namespace lsst::qserv::replica
+
+#endif  // LSST_QSERV_REPLICA_QSERVCZARMGTREQUEST_H
diff --git a/src/replica/QservMgtRequest.cc b/src/replica/QservMgtRequest.cc
index f018895fd..3f6101c27 100644
--- a/src/replica/QservMgtRequest.cc
+++ b/src/replica/QservMgtRequest.cc
@@ -30,7 +30,6 @@
 #include "http/MetaModule.h"
 #include "replica/Configuration.h"
 #include "replica/Common.h"
-#include "replica/DatabaseServices.h"
 
 // LSST headers
 #include "lsst/log/Log.h"
@@ -87,11 +86,12 @@ string QservMgtRequest::state2string(ExtendedState state) {
 }
 
 QservMgtRequest::QservMgtRequest(ServiceProvider::Ptr const& serviceProvider, string const& type,
-                                 string const& workerName)
+                                 string const& remoteServiceKey, string const& remoteServiceId)
         : _serviceProvider(serviceProvider),
           _type(type),
           _id(Generators::uniqueId()),
-          _workerName(workerName),
+          _remoteServiceKey(remoteServiceKey),
+          _remoteServiceId(remoteServiceId),
           _state(State::CREATED),
           _extendedState(ExtendedState::NONE) {
     // This report is used solely for debugging purposes to allow tracking
@@ -139,16 +139,6 @@ void QservMgtRequest::start(string const& jobId, unsigned int requestExpirationI
     // which was created upon the object construction.
     _performance.setUpdateStart();
 
-    // Check if configuration parameters are valid
-    auto const config = _serviceProvider->config();
-    if (!config->isKnownWorker(_workerName)) {
-        LOGS(_log, LOG_LVL_ERROR,
-             context_ << " ** MISCONFIGURED ** unknown worker: '" << _workerName << "'.");
-        _setState(lock, State::FINISHED, ExtendedState::CONFIG_ERROR);
-        notify(lock);
-        return;
-    }
-
     // Build an association with the corresponding parent job (optional).
     _jobId = jobId;
 
@@ -156,6 +146,7 @@ void QservMgtRequest::start(string const& jobId, unsigned int requestExpirationI
     // creating and starting the request.
     unsigned int actualExpirationIvalSec = requestExpirationIvalSec;
     if (0 == actualExpirationIvalSec) {
+        auto const config = _serviceProvider->config();
         actualExpirationIvalSec = config->get<unsigned int>("xrootd", "request-timeout-sec");
     }
 
@@ -201,12 +192,12 @@ void QservMgtRequest::cancel() {
 void QservMgtRequest::createHttpReq(replica::Lock const& lock, string const& service, string const& query) {
     _assertNotStarted(__func__);
     string const target = service + query + string(query.empty() ? "?" : "&") + "id" + _id +
-                          "&instance_id=" + _serviceProvider->instanceId() + "&worker=" + _workerName +
-                          "&version=" + to_string(http::MetaModule::version);
+                          "&instance_id=" + _serviceProvider->instanceId() + "&" + _remoteServiceKey + "=" +
+                          _remoteServiceId + "&version=" + to_string(http::MetaModule::version);
     _httpRequest = http::AsyncReq::create(
             _serviceProvider->io_service(),
             [self = shared_from_this()](shared_ptr<http::AsyncReq> const&) { self->_processResponse(); },
-            http::Method::GET, _getHostPortTracker(), target);
+            http::Method::GET, getHostPortTracker(), target);
 }
 
 void QservMgtRequest::createHttpReq(replica::Lock const& lock, http::Method method, string const& target,
@@ -215,7 +206,7 @@ void QservMgtRequest::createHttpReq(replica::Lock const& lock, http::Method meth
     json data = body;
     data["id"] = _id;
     data["instance_id"] = _serviceProvider->instanceId();
-    data["worker"] = _workerName;
+    data[_remoteServiceKey] = _remoteServiceId;
     data["auth_key"] = _serviceProvider->authKey();
     data["admin_auth_key"] = _serviceProvider->adminAuthKey();
     data["version"] = http::MetaModule::version;
@@ -223,7 +214,7 @@ void QservMgtRequest::createHttpReq(replica::Lock const& lock, http::Method meth
     _httpRequest = http::AsyncReq::create(
             _serviceProvider->io_service(),
             [self = shared_from_this()](shared_ptr<http::AsyncReq> const&) { self->_processResponse(); },
-            method, _getHostPortTracker(), target, data.dump(), headers);
+            method, getHostPortTracker(), target, data.dump(), headers);
 }
 
 void QservMgtRequest::finish(replica::Lock const& lock, ExtendedState extendedState,
@@ -243,12 +234,7 @@ void QservMgtRequest::finish(replica::Lock const& lock, ExtendedState extendedSt
     // We have to update the timestamp before invoking a user provided
     // callback on the completion of the operation.
     _performance.setUpdateFinish();
-
-    // TODO: temporarily disabled while this class is not supported by
-    //       the persistent backend.
-    //
-    // _serviceProvider->databaseServices()->saveState(*this, _performance, _serverError);
-
+    updatePersistentState(_performance, _serverError);
     notify(lock);
 
     // Unblock threads (if any) waiting on the synchronization call to the method wait().
@@ -256,14 +242,6 @@ void QservMgtRequest::finish(replica::Lock const& lock, ExtendedState extendedSt
     _onFinishCv.notify_all();
 }
 
-http::AsyncReq::GetHostPort QservMgtRequest::_getHostPortTracker() const {
-    return [config = _serviceProvider->config(),
-            workerName = _workerName](http::AsyncReq::HostPort const&) -> http::AsyncReq::HostPort {
-        auto const worker = config->worker(workerName);
-        return http::AsyncReq::HostPort{worker.qservWorker.host.addr, worker.qservWorker.port};
-    };
-}
-
 void QservMgtRequest::_processResponse() {
     string const context_ = context() + string(__func__) + " ";
     if (_state == State::FINISHED) return;
@@ -275,7 +253,7 @@ void QservMgtRequest::_processResponse() {
             try {
                 _info = json::parse(_httpRequest->responseBody());
                 if (_info.at("success").get<int>() == 0) {
-                    string const msg = "worker reported error: " + _info.at("error").get<string>();
+                    string const msg = "service reported error: " + _info.at("error").get<string>();
                     auto extendedState = ExtendedState::SERVER_BAD;
                     // Check for optional markers in the optional extended error section that might
                     // clarify an actual reason behind the failure.
@@ -295,7 +273,7 @@ void QservMgtRequest::_processResponse() {
                     finish(lock, dataReady(lock, _info));
                 }
             } catch (exception const& ex) {
-                string const msg = "failed to parse/process worker response, ex: " + string(ex.what());
+                string const msg = "failed to parse/process server response, ex: " + string(ex.what());
                 finish(lock, ExtendedState::SERVER_BAD_RESPONSE, msg);
             }
             break;
@@ -344,7 +322,7 @@ void QservMgtRequest::_setState(replica::Lock const& lock, State newState, Exten
         _extendedState = newExtendedState;
         _state = newState;
     }
-    _serviceProvider->databaseServices()->saveState(*this, _performance, _serverError);
+    updatePersistentState(_performance, _serverError);
 }
 
 }  // namespace lsst::qserv::replica
diff --git a/src/replica/QservMgtRequest.h b/src/replica/QservMgtRequest.h
index 9206756cf..8ca26c147 100644
--- a/src/replica/QservMgtRequest.h
+++ b/src/replica/QservMgtRequest.h
@@ -44,8 +44,8 @@
 namespace lsst::qserv::replica {
 
 /**
- * @brief QservMgtRequest is a base class for a family of the Qserv worker
- *   management requests within the master server.
+ * QservMgtRequest is a base class for a family of the Qserv management requests
+ * sent to different services.
  */
 class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
 public:
@@ -99,7 +99,7 @@ class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
     virtual ~QservMgtRequest();
 
     /// @return reference to a provider of services
-    std::shared_ptr<ServiceProvider> const& serviceProvider() { return _serviceProvider; }
+    std::shared_ptr<ServiceProvider> const& serviceProvider() const { return _serviceProvider; }
 
     /// @return string representing of the request type.
     std::string const& type() const { return _type; }
@@ -107,9 +107,6 @@ class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
     /// @return unique identifier of the request
     std::string const& id() const { return _id; }
 
-    /// @return name of a worker
-    std::string const& workerName() const { return _workerName; }
-
     /// @return primary status of the request
     State state() const { return _state; }
 
@@ -132,7 +129,7 @@ class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
     std::string const& jobId() const;
 
     /**
-     * @return The info object returned by the worker.
+     * @return The info object returned by the service.
      * @throw std::logic_error if called before the request finishes or if it failed.
      */
     nlohmann::json const& info() const;
@@ -169,10 +166,11 @@ class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
      * @brief Construct the request with the pointer to the services provider.
      * @param serviceProvider Is required to access configuration services.
      * @param type The type name of he request (used for debugging and error reporting).
-     * @param worker The name of a worker.
+     * @param remoteServiceKey The key assiciated with the remote service.
+     * @param remoteServiceId The unique identifier of the remote service.
      */
     QservMgtRequest(std::shared_ptr<ServiceProvider> const& serviceProvider, std::string const& type,
-                    std::string const& worker);
+                    std::string const& remoteServiceKey, std::string const& remoteServiceId);
 
     /// @return A shared pointer of the desired subclass (no dynamic type checking).
     template <class T>
@@ -220,7 +218,7 @@ class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
 
     /**
      * @brief Notify a subclass that a data object was was succesfully retrieved
-     *   from the worker.
+     *   from the service.
      *
      * This method allows subclasses to implement the optional result validation and processing,
      * including a translation of the JSON object into the subclas-specific result type.
@@ -246,7 +244,7 @@ class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
      * @param lock A lock on QservMgtRequest::_mtx must be acquired before
      *   calling this method.
      * @param extendedState The new extended state.
-     * @param serverError (optional) error message from a Qserv worker service.
+     * @param serverError (optional) error message from a service.
      */
     void finish(replica::Lock const& lock, ExtendedState extendedState, std::string const& serverError = "");
 
@@ -315,10 +313,19 @@ class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
     /// Mutex guarding internal state (also used by subclasses)
     mutable replica::Mutex _mtx;
 
-private:
-    /// @return The callback function for tracking connection parameters of the worker.
-    http::AsyncReq::GetHostPort _getHostPortTracker() const;
+    /// @return The callback function for tracking connection parameters of the remote service.
+    virtual http::AsyncReq::GetHostPort getHostPortTracker() const = 0;
 
+    /**
+     * Update the persistent state from the subclass's context.
+     * @note Not all request classes have persistent states.
+     * @param performance Performance stats of the request.
+     * @param serverError The server error (if any).
+     */
+    virtual void updatePersistentState(Performance const& performance, std::string const& serverError) const {
+    }
+
+private:
     /// Extract and process data of the completed request. Notify a subclass in case of success.
     void _processResponse();
 
@@ -363,7 +370,8 @@ class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
 
     std::string const _type;
     std::string const _id;
-    std::string const _workerName;
+    std::string const _remoteServiceKey;
+    std::string const _remoteServiceId;
 
     // Two-level state of a request
     std::atomic<State> _state;                  ///< The primary state.
@@ -375,8 +383,8 @@ class QservMgtRequest : public std::enable_shared_from_this<QservMgtRequest> {
     Performance _performance;  ///< Performance counters.
     std::string _jobId;        ///< An identifier of the parent job which started the request.
 
-    std::shared_ptr<http::AsyncReq> _httpRequest;  ///< The actual request sent to the worker.
-    nlohmann::json _info;                          ///< The data object returned by the worker.
+    std::shared_ptr<http::AsyncReq> _httpRequest;  ///< The actual request sent to the service.
+    nlohmann::json _info;                          ///< The data object returned by the service.
 
     // Synchronization primitives for implementing QservMgtRequest::wait()
 
diff --git a/src/replica/QservWorkerMgtRequest.cc b/src/replica/QservWorkerMgtRequest.cc
new file mode 100644
index 000000000..bfb916c73
--- /dev/null
+++ b/src/replica/QservWorkerMgtRequest.cc
@@ -0,0 +1,59 @@
+/*
+ * LSST Data Management System
+ *
+ * This product includes software developed by the
+ * LSST Project (http://www.lsst.org/).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the LSST License Statement and
+ * the GNU General Public License along with this program.  If not,
+ * see <http://www.lsstcorp.org/LegalNotices/>.
+ */
+
+// Class header
+#include "replica/QservWorkerMgtRequest.h"
+
+// System headers
+#include <stdexcept>
+
+// Qserv headers
+#include "replica/Configuration.h"
+#include "replica/DatabaseServices.h"
+#include "replica/ServiceProvider.h"
+
+using namespace std;
+
+namespace lsst::qserv::replica {
+
+QservWorkerMgtRequest::QservWorkerMgtRequest(ServiceProvider::Ptr const& serviceProvider, string const& type,
+                                             string const& workerName)
+        : QservMgtRequest(serviceProvider, type, "worker", workerName), _workerName(workerName) {
+    if (!serviceProvider->config()->isKnownWorker(_workerName)) {
+        throw invalid_argument("QservWorkerMgtRequest::" + string(__func__) + " unknown worker: '" +
+                               _workerName + "'.");
+    }
+}
+
+http::AsyncReq::GetHostPort QservWorkerMgtRequest::getHostPortTracker() const {
+    return [config = serviceProvider()->config(),
+            workerName = _workerName](http::AsyncReq::HostPort const&) -> http::AsyncReq::HostPort {
+        auto const worker = config->worker(workerName);
+        return http::AsyncReq::HostPort{worker.qservWorker.host.addr, worker.qservWorker.port};
+    };
+}
+
+void QservWorkerMgtRequest::updatePersistentState(Performance const& performance,
+                                                  std::string const& serverError) const {
+    serviceProvider()->databaseServices()->saveState(*this, performance, serverError);
+}
+
+}  // namespace lsst::qserv::replica
diff --git a/src/replica/QservWorkerMgtRequest.h b/src/replica/QservWorkerMgtRequest.h
new file mode 100644
index 000000000..ed8b4647a
--- /dev/null
+++ b/src/replica/QservWorkerMgtRequest.h
@@ -0,0 +1,79 @@
+/*
+ * LSST Data Management System
+ *
+ * This product includes software developed by the
+ * LSST Project (http://www.lsst.org/).
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the LSST License Statement and
+ * the GNU General Public License along with this program.  If not,
+ * see <http://www.lsstcorp.org/LegalNotices/>.
+ */
+#ifndef LSST_QSERV_REPLICA_QSERVWORKERMGTREQUEST_H
+#define LSST_QSERV_REPLICA_QSERVWORKERMGTREQUEST_H
+
+// System headers
+#include <memory>
+#include <string>
+
+// Qserv headers
+#include "http/AsyncReq.h"
+#include "replica/QservMgtRequest.h"
+
+// Forward declarations
+namespace lsst::qserv::replica {
+class Performance;
+class ServiceProvider;
+}  // namespace lsst::qserv::replica
+
+// This header declarations
+namespace lsst::qserv::replica {
+
+/**
+ * @brief QservWorkerMgtRequest is a base class for a family of the Qserv worker
+ *   management requests within the master server.
+ */
+class QservWorkerMgtRequest : public QservMgtRequest {
+public:
+    QservWorkerMgtRequest() = delete;
+    QservWorkerMgtRequest(QservWorkerMgtRequest const&) = delete;
+    QservWorkerMgtRequest& operator=(QservWorkerMgtRequest const&) = delete;
+
+    virtual ~QservWorkerMgtRequest() override = default;
+
+    /// @return name of a worker
+    std::string const& workerName() const { return _workerName; }
+
+protected:
+    /**
+     * @brief Construct the request with the pointer to the services provider.
+     * @param serviceProvider Is required to access configuration services.
+     * @param type The type name of he request (used for debugging and error reporting).
+     * @param workerName The name of the Qserv worker.
+     */
+    QservWorkerMgtRequest(std::shared_ptr<ServiceProvider> const& serviceProvider, std::string const& type,
+                          std::string const& workerName);
+
+    /// @return The callback function for tracking connection parameters of the worker.
+    virtual http::AsyncReq::GetHostPort getHostPortTracker() const override;
+
+    /// @see QservMgtRequest::updatePersistentState
+    virtual void updatePersistentState(Performance const& performance,
+                                       std::string const& serverError) const override;
+
+private:
+    std::string const _workerName;
+};
+
+}  // namespace lsst::qserv::replica
+
+#endif  // LSST_QSERV_REPLICA_QSERVWORKERMGTREQUEST_H
diff --git a/src/replica/RemoveReplicaQservMgtRequest.cc b/src/replica/RemoveReplicaQservMgtRequest.cc
index 3d2899090..9380fed76 100644
--- a/src/replica/RemoveReplicaQservMgtRequest.cc
+++ b/src/replica/RemoveReplicaQservMgtRequest.cc
@@ -52,7 +52,7 @@ RemoveReplicaQservMgtRequest::RemoveReplicaQservMgtRequest(
         shared_ptr<ServiceProvider> const& serviceProvider, string const& worker, unsigned int chunk,
         vector<string> const& databases, bool force,
         RemoveReplicaQservMgtRequest::CallbackType const& onFinish)
-        : QservMgtRequest(serviceProvider, "QSERV_REMOVE_REPLICA", worker),
+        : QservWorkerMgtRequest(serviceProvider, "QSERV_REMOVE_REPLICA", worker),
           _chunk(chunk),
           _databases(databases),
           _force(force),
diff --git a/src/replica/RemoveReplicaQservMgtRequest.h b/src/replica/RemoveReplicaQservMgtRequest.h
index b95359136..a97e147e5 100644
--- a/src/replica/RemoveReplicaQservMgtRequest.h
+++ b/src/replica/RemoveReplicaQservMgtRequest.h
@@ -32,7 +32,7 @@
 #include "nlohmann/json.hpp"
 
 // Qserv headers
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 
 namespace lsst::qserv::replica {
 class ServiceProvider;
@@ -45,7 +45,7 @@ namespace lsst::qserv::replica {
  * Class RemoveReplicaQservMgtRequest implements a request notifying Qserv workers
  * on new chunks added to the database.
  */
-class RemoveReplicaQservMgtRequest : public QservMgtRequest {
+class RemoveReplicaQservMgtRequest : public QservWorkerMgtRequest {
 public:
     typedef std::shared_ptr<RemoveReplicaQservMgtRequest> Ptr;
 
@@ -56,7 +56,7 @@ class RemoveReplicaQservMgtRequest : public QservMgtRequest {
     RemoveReplicaQservMgtRequest(RemoveReplicaQservMgtRequest const&) = delete;
     RemoveReplicaQservMgtRequest& operator=(RemoveReplicaQservMgtRequest const&) = delete;
 
-    virtual ~RemoveReplicaQservMgtRequest() final = default;
+    virtual ~RemoveReplicaQservMgtRequest() override = default;
 
     /**
      * Static factory method is needed to prevent issues with the lifespan
@@ -86,14 +86,14 @@ class RemoveReplicaQservMgtRequest : public QservMgtRequest {
     bool force() const { return _force; }
 
     /// @see QservMgtRequest::extendedPersistentState()
-    virtual std::list<std::pair<std::string, std::string>> extendedPersistentState() const final;
+    virtual std::list<std::pair<std::string, std::string>> extendedPersistentState() const override;
 
 protected:
     /// @see QservMgtRequest::createHttpReqImpl
-    virtual void createHttpReqImpl(replica::Lock const& lock) final;
+    virtual void createHttpReqImpl(replica::Lock const& lock) override;
 
     /// @see QservMgtRequest::notify
-    virtual void notify(replica::Lock const& lock) final;
+    virtual void notify(replica::Lock const& lock) override;
 
 private:
     /// @see RemoveReplicaQservMgtRequest::create()
diff --git a/src/replica/SetReplicasQservMgtRequest.cc b/src/replica/SetReplicasQservMgtRequest.cc
index 160270a7b..439503226 100644
--- a/src/replica/SetReplicasQservMgtRequest.cc
+++ b/src/replica/SetReplicasQservMgtRequest.cc
@@ -59,7 +59,7 @@ SetReplicasQservMgtRequest::SetReplicasQservMgtRequest(
         ServiceProvider::Ptr const& serviceProvider, string const& worker,
         QservReplicaCollection const& newReplicas, vector<string> const& databases, bool force,
         SetReplicasQservMgtRequest::CallbackType const& onFinish)
-        : QservMgtRequest(serviceProvider, "QSERV_SET_REPLICAS", worker),
+        : QservWorkerMgtRequest(serviceProvider, "QSERV_SET_REPLICAS", worker),
           _newReplicas(newReplicas),
           _databases(databases),
           _force(force),
diff --git a/src/replica/SetReplicasQservMgtRequest.h b/src/replica/SetReplicasQservMgtRequest.h
index 8ee99083e..1f0b59e7f 100644
--- a/src/replica/SetReplicasQservMgtRequest.h
+++ b/src/replica/SetReplicasQservMgtRequest.h
@@ -29,7 +29,7 @@
 #include <utility>
 
 // Qserv headers
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 #include "replica/ReplicaInfo.h"
 
 namespace lsst::qserv::replica {
@@ -43,7 +43,7 @@ namespace lsst::qserv::replica {
  * Class SetReplicasQservMgtRequest implements a request for configuring chunk
  * inventory=ies (both transient and persistent) at Qserv workers.
  */
-class SetReplicasQservMgtRequest : public QservMgtRequest {
+class SetReplicasQservMgtRequest : public QservWorkerMgtRequest {
 public:
     typedef std::shared_ptr<SetReplicasQservMgtRequest> Ptr;
 
@@ -54,7 +54,7 @@ class SetReplicasQservMgtRequest : public QservMgtRequest {
     SetReplicasQservMgtRequest(SetReplicasQservMgtRequest const&) = delete;
     SetReplicasQservMgtRequest& operator=(SetReplicasQservMgtRequest const&) = delete;
 
-    virtual ~SetReplicasQservMgtRequest() final = default;
+    virtual ~SetReplicasQservMgtRequest() override = default;
 
     /**
      * Static factory method is needed to prevent issues with the lifespan
@@ -93,18 +93,18 @@ class SetReplicasQservMgtRequest : public QservMgtRequest {
     QservReplicaCollection const& replicas() const;
 
     /// @see QservMgtRequest::extendedPersistentState()
-    std::list<std::pair<std::string, std::string>> extendedPersistentState() const final;
+    std::list<std::pair<std::string, std::string>> extendedPersistentState() const override;
 
 protected:
     /// @see QservMgtRequest::createHttpReqImpl()
-    virtual void createHttpReqImpl(replica::Lock const& lock) final;
+    virtual void createHttpReqImpl(replica::Lock const& lock) override;
 
     /// @see QservMgtRequest::dataReady()
     virtual QservMgtRequest::ExtendedState dataReady(replica::Lock const& lock,
-                                                     nlohmann::json const& data) final;
+                                                     nlohmann::json const& data) override;
 
     /// @see QservMgtRequest::notify
-    virtual void notify(replica::Lock const& lock) final;
+    virtual void notify(replica::Lock const& lock) override;
 
 private:
     /// @see SetReplicasQservMgtRequest::create()
diff --git a/src/replica/TestEchoQservMgtRequest.cc b/src/replica/TestEchoQservMgtRequest.cc
index fbc16db0f..94427ef2f 100644
--- a/src/replica/TestEchoQservMgtRequest.cc
+++ b/src/replica/TestEchoQservMgtRequest.cc
@@ -49,7 +49,9 @@ shared_ptr<TestEchoQservMgtRequest> TestEchoQservMgtRequest::create(
 TestEchoQservMgtRequest::TestEchoQservMgtRequest(shared_ptr<ServiceProvider> const& serviceProvider,
                                                  string const& worker, string const& data,
                                                  TestEchoQservMgtRequest::CallbackType const& onFinish)
-        : QservMgtRequest(serviceProvider, "QSERV_TEST_ECHO", worker), _data(data), _onFinish(onFinish) {}
+        : QservWorkerMgtRequest(serviceProvider, "QSERV_TEST_ECHO", worker),
+          _data(data),
+          _onFinish(onFinish) {}
 
 string const& TestEchoQservMgtRequest::dataEcho() const {
     if (not((state() == State::FINISHED) and (extendedState() == ExtendedState::SUCCESS))) {
diff --git a/src/replica/TestEchoQservMgtRequest.h b/src/replica/TestEchoQservMgtRequest.h
index bd4cf521d..5e6f204ff 100644
--- a/src/replica/TestEchoQservMgtRequest.h
+++ b/src/replica/TestEchoQservMgtRequest.h
@@ -31,7 +31,7 @@
 #include "nlohmann/json.hpp"
 
 // Qserv headers
-#include "replica/QservMgtRequest.h"
+#include "replica/QservWorkerMgtRequest.h"
 
 namespace lsst::qserv::replica {
 class ServiceProvider;
@@ -44,7 +44,7 @@ namespace lsst::qserv::replica {
  * Class TestEchoQservMgtRequest a special kind of requests
  * for testing Qserv workers.
  */
-class TestEchoQservMgtRequest : public QservMgtRequest {
+class TestEchoQservMgtRequest : public QservWorkerMgtRequest {
 public:
     typedef std::shared_ptr<TestEchoQservMgtRequest> Ptr;
 
@@ -55,7 +55,7 @@ class TestEchoQservMgtRequest : public QservMgtRequest {
     TestEchoQservMgtRequest(TestEchoQservMgtRequest const&) = delete;
     TestEchoQservMgtRequest& operator=(TestEchoQservMgtRequest const&) = delete;
 
-    virtual ~TestEchoQservMgtRequest() final = default;
+    virtual ~TestEchoQservMgtRequest() override = default;
 
     /**
      * Static factory method is needed to prevent issues with the lifespan
@@ -83,18 +83,18 @@ class TestEchoQservMgtRequest : public QservMgtRequest {
     std::string const& dataEcho() const;
 
     /// @see QservMgtRequest::extendedPersistentState()
-    virtual std::list<std::pair<std::string, std::string>> extendedPersistentState() const final;
+    virtual std::list<std::pair<std::string, std::string>> extendedPersistentState() const override;
 
 protected:
     /// @see QservMgtRequest::createHttpReqImpl()
-    virtual void createHttpReqImpl(replica::Lock const& lock) final;
+    virtual void createHttpReqImpl(replica::Lock const& lock) override;
 
     /// @see QservMgtRequest::dataReady()
     virtual QservMgtRequest::ExtendedState dataReady(replica::Lock const& lock,
-                                                     nlohmann::json const& data) final;
+                                                     nlohmann::json const& data) override;
 
     /// @see QservMgtRequest::notify()
-    virtual void notify(replica::Lock const& lock) final;
+    virtual void notify(replica::Lock const& lock) override;
 
 private:
     /// @see TestEchoQservMgtRequest::create()