diff --git a/idl/backup.thrift b/idl/backup.thrift
index a73fa12e12..c4165606ab 100644
--- a/idl/backup.thrift
+++ b/idl/backup.thrift
@@ -184,16 +184,28 @@ struct start_backup_app_response
     3:optional i64      backup_id;
 }
 
+enum backup_status
+{
+    UNINITIALIZED,
+    CHECKPOINTING,
+    CHECKPOINTED,
+    UPLOADING,
+    SUCCEED,
+    FAILED,
+    CANCELED
+}
+
 struct backup_item
 {
     1:i64           backup_id;
-    2:string        app_name;
-    3:string        backup_provider_type;
+    2:i32           app_id;
+    3:string        app_name;
+    4:string        backup_provider_type;
     // user specified backup_path.
-    4:string        backup_path;
-    5:i64           start_time_ms;
-    6:i64           end_time_ms;
-    7:bool          is_backup_failed;
+    5:string        backup_path;
+    6:i64           start_time_ms;
+    7:i64           end_time_ms;
+    8:backup_status status;
 }
 
 struct query_backup_status_request
diff --git a/src/common/json_helper.h b/src/common/json_helper.h
index d56bcecba6..c13f02965d 100644
--- a/src/common/json_helper.h
+++ b/src/common/json_helper.h
@@ -402,6 +402,8 @@ ENUM_TYPE_SERIALIZATION(dsn::replication::partition_status::type,
 ENUM_TYPE_SERIALIZATION(dsn::app_status::type, dsn::app_status::AS_INVALID)
 ENUM_TYPE_SERIALIZATION(dsn::replication::bulk_load_status::type,
                         dsn::replication::bulk_load_status::BLS_INVALID)
+ENUM_TYPE_SERIALIZATION(dsn::replication::backup_status::type,
+                        dsn::replication::backup_status::UNINITIALIZED)
 
 // json serialization for gpid, we treat it as string: "app_id.partition_id"
 inline void json_encode(JsonWriter &out, const dsn::gpid &pid)
@@ -456,6 +458,8 @@ inline void json_encode(JsonWriter &out, const dsn::replication::file_meta &f_me
 inline bool json_decode(const JsonObject &in, dsn::replication::file_meta &f_meta);
 inline void json_encode(JsonWriter &out, const dsn::replication::bulk_load_metadata &metadata);
 inline bool json_decode(const JsonObject &in, dsn::replication::bulk_load_metadata &metadata);
+inline void json_encode(JsonWriter &out, const dsn::replication::backup_item &backup_item);
+inline bool json_decode(const JsonObject &in, dsn::replication::backup_item &backup_item);
 
 template <typename T>
 inline void json_encode_iterable(JsonWriter &out, const T &t)
@@ -745,5 +749,15 @@ NON_MEMBER_JSON_SERIALIZATION(dsn::app_info,
 NON_MEMBER_JSON_SERIALIZATION(dsn::replication::file_meta, name, size, md5)
 
 NON_MEMBER_JSON_SERIALIZATION(dsn::replication::bulk_load_metadata, files, file_total_size)
+
+NON_MEMBER_JSON_SERIALIZATION(dsn::replication::backup_item,
+                              backup_id,
+                              app_id,
+                              app_name,
+                              backup_provider_type,
+                              backup_path,
+                              start_time_ms,
+                              end_time_ms,
+                              status)
 } // namespace json
 } // namespace dsn
diff --git a/src/common/replication_enums.h b/src/common/replication_enums.h
index bd16d81415..e2ab4f6c9b 100644
--- a/src/common/replication_enums.h
+++ b/src/common/replication_enums.h
@@ -165,6 +165,18 @@ ENUM_REG(replication::manual_compaction_status::RUNNING)
 ENUM_REG(replication::manual_compaction_status::FINISHED)
 ENUM_END2(replication::manual_compaction_status::type, manual_compaction_status)
 
+ENUM_BEGIN2(replication::backup_status::type,
+            backup_status,
+            replication::backup_status::UNINITIALIZED)
+ENUM_REG(replication::backup_status::UNINITIALIZED)
+ENUM_REG(replication::backup_status::CHECKPOINTING)
+ENUM_REG(replication::backup_status::CHECKPOINTED)
+ENUM_REG(replication::backup_status::UPLOADING)
+ENUM_REG(replication::backup_status::SUCCEED)
+ENUM_REG(replication::backup_status::FAILED)
+ENUM_REG(replication::backup_status::CANCELED)
+ENUM_END2(replication::backup_status::type, backup_status)
+
 USER_DEFINED_ENUM_FORMATTER(app_status::type)
 namespace replication {
 USER_DEFINED_ENUM_FORMATTER(bulk_load_status::type)
diff --git a/src/meta/backup_engine.cpp b/src/meta/meta_backup_engine.cpp
similarity index 73%
rename from src/meta/backup_engine.cpp
rename to src/meta/meta_backup_engine.cpp
index 7197f4e48b..e70cbd599d 100644
--- a/src/meta/backup_engine.cpp
+++ b/src/meta/meta_backup_engine.cpp
@@ -15,31 +15,31 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <algorithm>
 #include <chrono>
-#include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "backup_types.h"
 #include "block_service/block_service.h"
-#include "block_service/block_service_manager.h"
 #include "common/backup_common.h"
 #include "common/gpid.h"
 #include "common/json_helper.h"
 #include "common/replication.codes.h"
 #include "dsn.layer2_types.h"
-#include "meta/backup_engine.h"
 #include "meta/meta_backup_service.h"
 #include "meta/meta_data.h"
 #include "meta/meta_service.h"
+#include "meta/server_state.h"
+#include "meta_backup_engine.h"
 #include "rpc/dns_resolver.h"
 #include "rpc/rpc_holder.h"
 #include "rpc/rpc_host_port.h"
 #include "runtime/api_layer1.h"
-#include "server_state.h"
 #include "task/async_calls.h"
 #include "task/task.h"
 #include "task/task_code.h"
@@ -48,6 +48,7 @@
 #include "utils/blob.h"
 #include "utils/chrono_literals.h"
 #include "utils/error_code.h"
+#include "utils/fail_point.h"
 #include "utils/filesystem.h"
 #include "utils/fmt_logging.h"
 #include "utils/zlocks.h"
@@ -55,65 +56,85 @@
 namespace dsn {
 namespace replication {
 
-backup_engine::backup_engine(backup_service *service)
-    : _backup_service(service), _block_service(nullptr), _backup_path(""), _is_backup_failed(false)
+meta_backup_engine::meta_backup_engine(meta_service *meta_svc, bool is_periodic)
+    : _meta_svc(meta_svc), _is_periodic_backup(is_periodic)
 {
 }
 
-backup_engine::~backup_engine() { _tracker.cancel_outstanding_tasks(); }
+meta_backup_engine::~meta_backup_engine() { _tracker.cancel_outstanding_tasks(); }
 
-error_code backup_engine::init_backup(int32_t app_id)
+// ThreadPool: THREAD_POOL_DEFAULT
+void meta_backup_engine::init_backup(int32_t app_id,
+                                     int32_t partition_count,
+                                     const std::string &app_name,
+                                     const std::string &provider,
+                                     const std::string &backup_root_path)
 {
-    std::string app_name;
-    int partition_count;
-    {
-        zauto_read_lock l;
-        _backup_service->get_state()->lock_read(l);
-        std::shared_ptr<app_state> app = _backup_service->get_state()->get_app(app_id);
-        if (app == nullptr || app->status != app_status::AS_AVAILABLE) {
-            LOG_ERROR("app {} is not available, couldn't do backup now.", app_id);
-            return ERR_INVALID_STATE;
-        }
-        app_name = app->app_name;
-        partition_count = app->partition_count;
-    }
+    zauto_write_lock l(_lock);
 
-    zauto_lock lock(_lock);
     _backup_status.clear();
     for (int i = 0; i < partition_count; ++i) {
-        _backup_status.emplace(i, backup_status::UNALIVE);
+        _backup_status.emplace_back(backup_status::UNINITIALIZED);
     }
     _cur_backup.app_id = app_id;
     _cur_backup.app_name = app_name;
     _cur_backup.backup_id = static_cast<int64_t>(dsn_now_ms());
     _cur_backup.start_time_ms = _cur_backup.backup_id;
-    return ERR_OK;
+    _cur_backup.backup_provider_type = provider;
+    _cur_backup.backup_path = backup_root_path;
+    _cur_backup.status = backup_status::UNINITIALIZED;
+    _is_backup_failed = false;
+    _is_backup_canceled = false;
 }
 
-error_code backup_engine::set_block_service(const std::string &provider)
+// ThreadPool: THREAD_POOL_DEFAULT
+void meta_backup_engine::start()
 {
-    _provider_type = provider;
-    _block_service = _backup_service->get_meta_service()
-                         ->get_block_service_manager()
-                         .get_or_create_block_filesystem(provider);
-    if (_block_service == nullptr) {
-        return ERR_INVALID_PARAMETERS;
+    LOG_DEBUG("App[{}] start {} backup[{}] on {}, root_path = {}",
+              _cur_backup.app_name,
+              _is_periodic_backup ? "periodic" : "onetime",
+              _cur_backup.backup_id,
+              _cur_backup.backup_provider_type,
+              _cur_backup.backup_path);
+    error_code err = write_app_info();
+    if (err != ERR_OK) {
+        LOG_ERROR("backup_id({}): backup meta data for app {} failed, error {}",
+                  _cur_backup.backup_id,
+                  _cur_backup.app_id,
+                  err);
+        update_backup_item_on_remote_storage(backup_status::FAILED, dsn_now_ms());
+        return;
+    }
+    update_backup_item_on_remote_storage(backup_status::CHECKPOINTING);
+    FAIL_POINT_INJECT_F("meta_backup_engine_start", [](absl::string_view) {});
+    for (auto i = 0; i < _backup_status.size(); ++i) {
+        zauto_write_lock l(_lock);
+        _backup_status[i] = backup_status::CHECKPOINTING;
+        tasking::enqueue(LPC_DEFAULT_CALLBACK, &_tracker, [this, i]() {
+            backup_app_partition(gpid(_cur_backup.app_id, i));
+        });
     }
-    return ERR_OK;
 }
 
-error_code backup_engine::set_backup_path(const std::string &path)
+// ThreadPool: THREAD_POOL_DEFAULT
+error_code meta_backup_engine::write_app_info()
 {
-    if (_block_service && _block_service->is_root_path_set()) {
-        return ERR_INVALID_PARAMETERS;
-    }
-    LOG_INFO("backup path is set to {}.", path);
-    _backup_path = path;
+    // TODO(heyuchen): TBD
+    // guoningshen: write app info on block service
     return ERR_OK;
 }
 
-error_code backup_engine::write_backup_file(const std::string &file_name,
-                                            const dsn::blob &write_buffer)
+// ThreadPool: THREAD_POOL_DEFAULT
+void meta_backup_engine::update_backup_item_on_remote_storage(backup_status::type new_status,
+                                                              int64_t end_time)
+{
+    // TODO(heyuchen): TBD
+}
+
+// TODO(heyuchen): update following functions
+
+error_code meta_backup_engine::write_backup_file(const std::string &file_name,
+                                                 const dsn::blob &write_buffer)
 {
     dist::block_service::create_file_request create_file_req;
     create_file_req.ignore_metadata = true;
@@ -143,7 +164,7 @@ error_code backup_engine::write_backup_file(const std::string &file_name,
     return err;
 }
 
-error_code backup_engine::backup_app_meta()
+error_code meta_backup_engine::backup_app_meta()
 {
     dsn::blob app_info_buffer;
     {
@@ -168,7 +189,7 @@ error_code backup_engine::backup_app_meta()
     return write_backup_file(file_name, app_info_buffer);
 }
 
-void backup_engine::backup_app_partition(const gpid &pid)
+void meta_backup_engine::backup_app_partition(const gpid &pid)
 {
     dsn::host_port partition_primary;
     {
@@ -178,7 +199,7 @@ void backup_engine::backup_app_partition(const gpid &pid)
         if (app == nullptr || app->status != app_status::AS_AVAILABLE) {
             LOG_ERROR("app {} is not available, couldn't do backup now.", pid.get_app_id());
 
-            zauto_lock lock(_lock);
+            zauto_write_lock lock(_lock);
             _is_backup_failed = true;
             return;
         }
@@ -222,12 +243,12 @@ void backup_engine::backup_app_partition(const gpid &pid)
                  on_backup_reply(err, rpc.response(), pid, partition_primary);
              });
 
-    zauto_lock l(_lock);
-    _backup_status[pid.get_partition_index()] = backup_status::ALIVE;
+    zauto_write_lock l(_lock);
+    _backup_status[pid.get_partition_index()] = backup_status::CHECKPOINTING;
 }
 
-inline void backup_engine::handle_replica_backup_failed(const backup_response &response,
-                                                        const gpid pid)
+inline void meta_backup_engine::handle_replica_backup_failed(const backup_response &response,
+                                                             const gpid pid)
 {
     CHECK_EQ(response.pid, pid);
     CHECK_EQ(response.backup_id, _cur_backup.backup_id);
@@ -236,13 +257,13 @@ inline void backup_engine::handle_replica_backup_failed(const backup_response &r
               _cur_backup.backup_id,
               pid,
               response.err);
-    zauto_lock l(_lock);
+    zauto_write_lock l(_lock);
     // if one partition fail, the whole backup plan fail.
     _is_backup_failed = true;
     _backup_status[pid.get_partition_index()] = backup_status::FAILED;
 }
 
-inline void backup_engine::retry_backup(const dsn::gpid pid)
+inline void meta_backup_engine::retry_backup(const dsn::gpid pid)
 {
     tasking::enqueue(
         LPC_DEFAULT_CALLBACK,
@@ -252,13 +273,13 @@ inline void backup_engine::retry_backup(const dsn::gpid pid)
         std::chrono::seconds(1));
 }
 
-void backup_engine::on_backup_reply(const error_code err,
-                                    const backup_response &response,
-                                    const gpid pid,
-                                    const host_port &primary)
+void meta_backup_engine::on_backup_reply(const error_code err,
+                                         const backup_response &response,
+                                         const gpid pid,
+                                         const host_port &primary)
 {
     {
-        zauto_lock l(_lock);
+        zauto_read_lock l(_lock);
         // if backup of some partition failed, we would not handle response from other partitions.
         if (_is_backup_failed) {
             return;
@@ -293,8 +314,8 @@ void backup_engine::on_backup_reply(const error_code err,
         CHECK_EQ(response.backup_id, _cur_backup.backup_id);
         LOG_INFO("backup_id({}): backup for partition {} completed.", _cur_backup.backup_id, pid);
         {
-            zauto_lock l(_lock);
-            _backup_status[pid.get_partition_index()] = backup_status::COMPLETED;
+            zauto_write_lock l(_lock);
+            _backup_status[pid.get_partition_index()] = backup_status::SUCCEED;
         }
         complete_current_backup();
         return;
@@ -311,19 +332,20 @@ void backup_engine::on_backup_reply(const error_code err,
     retry_backup(pid);
 }
 
-void backup_engine::write_backup_info()
+void meta_backup_engine::write_backup_info()
 {
     std::string backup_root =
         dsn::utils::filesystem::path_combine(_backup_path, _backup_service->backup_root());
     std::string file_name = cold_backup::get_backup_info_file(backup_root, _cur_backup.backup_id);
-    blob buf = dsn::json::json_forwarder<app_backup_info>::encode(_cur_backup);
+    // Updated backup item struct, so need use another json method
+    blob buf = dsn::json::json_forwarder<backup_item>::encode(_cur_backup);
     error_code err = write_backup_file(file_name, buf);
     if (err == ERR_FS_INTERNAL) {
         LOG_ERROR(
             "backup_id({}): write backup info failed, error {}, do not try again for this error.",
             _cur_backup.backup_id,
             err);
-        zauto_lock l(_lock);
+        zauto_write_lock l(_lock);
         _is_backup_failed = true;
         return;
     }
@@ -341,16 +363,16 @@ void backup_engine::write_backup_info()
     LOG_INFO("backup_id({}): successfully wrote backup info, backup for app {} completed.",
              _cur_backup.backup_id,
              _cur_backup.app_id);
-    zauto_lock l(_lock);
+    zauto_write_lock l(_lock);
     _cur_backup.end_time_ms = dsn_now_ms();
 }
 
-void backup_engine::complete_current_backup()
+void meta_backup_engine::complete_current_backup()
 {
     {
-        zauto_lock l(_lock);
+        zauto_read_lock l(_lock);
         for (const auto &status : _backup_status) {
-            if (status.second != backup_status::COMPLETED) {
+            if (status != backup_status::SUCCEED) {
                 // backup for some partition was not finished.
                 return;
             }
@@ -360,43 +382,5 @@ void backup_engine::complete_current_backup()
     write_backup_info();
 }
 
-error_code backup_engine::start()
-{
-    error_code err = backup_app_meta();
-    if (err != ERR_OK) {
-        LOG_ERROR("backup_id({}): backup meta data for app {} failed, error {}",
-                  _cur_backup.backup_id,
-                  _cur_backup.app_id,
-                  err);
-        return err;
-    }
-    for (int i = 0; i < _backup_status.size(); ++i) {
-        tasking::enqueue(LPC_DEFAULT_CALLBACK, &_tracker, [this, i]() {
-            backup_app_partition(gpid(_cur_backup.app_id, i));
-        });
-    }
-    return ERR_OK;
-}
-
-bool backup_engine::is_in_progress() const
-{
-    zauto_lock l(_lock);
-    return _cur_backup.end_time_ms == 0 && !_is_backup_failed;
-}
-
-backup_item backup_engine::get_backup_item() const
-{
-    zauto_lock l(_lock);
-    backup_item item;
-    item.backup_id = _cur_backup.backup_id;
-    item.app_name = _cur_backup.app_name;
-    item.backup_path = _backup_path;
-    item.backup_provider_type = _provider_type;
-    item.start_time_ms = _cur_backup.start_time_ms;
-    item.end_time_ms = _cur_backup.end_time_ms;
-    item.is_backup_failed = _is_backup_failed;
-    return item;
-}
-
 } // namespace replication
 } // namespace dsn
diff --git a/src/meta/backup_engine.h b/src/meta/meta_backup_engine.h
similarity index 58%
rename from src/meta/backup_engine.h
rename to src/meta/meta_backup_engine.h
index 2f68b92b11..87ca945350 100644
--- a/src/meta/backup_engine.h
+++ b/src/meta/meta_backup_engine.h
@@ -17,10 +17,9 @@
 
 #pragma once
 
-#include <gtest/gtest_prod.h>
 #include <stdint.h>
-#include <map>
 #include <string>
+#include <vector>
 
 #include "backup_types.h"
 #include "common/json_helper.h"
@@ -40,14 +39,8 @@ class block_filesystem;
 } // namespace dist
 
 namespace replication {
-
-enum backup_status
-{
-    UNALIVE = 1,
-    ALIVE = 2,
-    COMPLETED = 3,
-    FAILED = 4
-};
+class backup_service;
+class meta_service;
 
 struct app_backup_info
 {
@@ -63,45 +56,81 @@ struct app_backup_info
     DEFINE_JSON_SERIALIZATION(backup_id, start_time_ms, end_time_ms, app_id, app_name)
 };
 
-class backup_service;
-
-class backup_engine
+///
+///           Meta backup status
+///
+///              start backup
+///                  |
+///                  v       Error/Cancel
+///            Checkpointing ------------->|
+///                  |                     |
+///                  v       Error/Cancel  |
+///              Uploading  -------------->|
+///                  |                     |
+///                  v                     v
+///               Succeed          Failed/Canceled
+///
+class meta_backup_engine
 {
 public:
-    backup_engine(backup_service *service);
-    ~backup_engine();
-
-    error_code init_backup(int32_t app_id);
-    error_code set_block_service(const std::string &provider);
-    error_code set_backup_path(const std::string &path);
-
-    error_code start();
+    explicit meta_backup_engine(meta_service *meta_svc, bool is_periodic);
+    ~meta_backup_engine();
 
     int64_t get_current_backup_id() const { return _cur_backup.backup_id; }
     int32_t get_backup_app_id() const { return _cur_backup.app_id; }
-    bool is_in_progress() const;
 
-    backup_item get_backup_item() const;
+    backup_item get_backup_item() const
+    {
+        zauto_read_lock l(_lock);
+        backup_item item = _cur_backup;
+        return item;
+    }
 
-private:
-    friend class backup_engine_test;
-    friend class backup_service_test;
+    bool is_in_progress() const
+    {
+        zauto_read_lock l(_lock);
+        return _cur_backup.end_time_ms == 0 && !_is_backup_failed && !_is_backup_canceled;
+    }
 
-    FRIEND_TEST(backup_engine_test, test_on_backup_reply);
-    FRIEND_TEST(backup_engine_test, test_backup_completed);
-    FRIEND_TEST(backup_engine_test, test_write_backup_info_failed);
+private:
+    void init_backup(int32_t app_id,
+                     int32_t partition_count,
+                     const std::string &app_name,
+                     const std::string &provider,
+                     const std::string &backup_root_path);
+    void start();
 
-    error_code write_backup_file(const std::string &file_name, const dsn::blob &write_buffer);
-    error_code backup_app_meta();
     void backup_app_partition(const gpid &pid);
     void on_backup_reply(error_code err,
                          const backup_response &response,
                          gpid pid,
                          const host_port &primary);
+    void retry_backup(const dsn::gpid pid);
+    void handle_replica_backup_failed(const backup_response &response, const gpid pid);
+    error_code write_backup_file(const std::string &file_name, const dsn::blob &write_buffer);
+    error_code write_app_info();
+
     void write_backup_info();
+
+    void update_backup_item_on_remote_storage(backup_status::type new_status, int64_t end_time = 0);
+
+private:
+    friend class meta_backup_engine_test;
+    meta_service *_meta_svc;
+    task_tracker _tracker;
+    mutable zrwlock_nr _lock; // {
+    // TODO(guoningshen): remove this flag cause we do not implement perodic in pegasus server
+    bool _is_periodic_backup;
+    bool _is_backup_failed{false};
+    bool _is_backup_canceled{false};
+    backup_item _cur_backup;
+    std::vector<backup_status::type> _backup_status;
+    // }
+    // TODO(heyuchen): remove following functions and vars
+private:
+    error_code backup_app_meta();
+
     void complete_current_backup();
-    void handle_replica_backup_failed(const backup_response &response, const gpid pid);
-    void retry_backup(const dsn::gpid pid);
 
     const std::string get_policy_name() const
     {
@@ -112,14 +141,6 @@ class backup_engine
     dist::block_service::block_filesystem *_block_service;
     std::string _backup_path;
     std::string _provider_type;
-    dsn::task_tracker _tracker;
-
-    // lock the following variables.
-    mutable dsn::zlock _lock;
-    bool _is_backup_failed;
-    app_backup_info _cur_backup;
-    // partition_id -> backup_status
-    std::map<int32_t, backup_status> _backup_status;
 };
 
 } // namespace replication
diff --git a/src/meta/meta_backup_service.cpp b/src/meta/meta_backup_service.cpp
index fa6ee4bc8b..7f77088ad4 100644
--- a/src/meta/meta_backup_service.cpp
+++ b/src/meta/meta_backup_service.cpp
@@ -16,38 +16,12 @@
 // under the License.
 
 #include <absl/strings/string_view.h>
-#include <boost/cstdint.hpp>
-#include <boost/lexical_cast.hpp>
-#include <fmt/core.h>
-#include <algorithm>
-#include <iterator>
-#include <type_traits>
-#include <utility>
 
-#include "block_service/block_service.h"
-#include "block_service/block_service_manager.h"
-#include "common/backup_common.h"
-#include "common/replication.codes.h"
-#include "common/replication_enums.h"
-#include "dsn.layer2_types.h"
-#include "meta/backup_engine.h"
-#include "meta/meta_data.h"
 #include "meta/meta_rpc_types.h"
-#include "meta/meta_state_service.h"
 #include "meta_backup_service.h"
 #include "meta_service.h"
-#include "runtime/api_layer1.h"
-#include "security/access_controller.h"
-#include "task/async_calls.h"
-#include "task/task_code.h"
-#include "server_state.h"
-#include "utils/autoref_ptr.h"
-#include "utils/blob.h"
-#include "utils/chrono_literals.h"
-#include "utils/defer.h"
 #include "utils/flags.h"
-#include "utils/fmt_logging.h"
-#include "utils/time_utils.h"
+#include "utils/metrics.h"
 
 DSN_DECLARE_int32(cold_backup_checkpoint_reserve_minutes);
 DSN_DECLARE_int32(fd_lease_seconds);
diff --git a/src/meta/test/meta_http_service_test.cpp b/src/meta/test/meta_http_service_test.cpp
index c70fc7fda8..8d8e4cc0bf 100644
--- a/src/meta/test/meta_http_service_test.cpp
+++ b/src/meta/test/meta_http_service_test.cpp
@@ -15,38 +15,24 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <chrono>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
-#include <vector>
 
-#include "backup_types.h"
 #include "bulk_load_types.h"
 #include "common/gpid.h"
 #include "common/replication_other_types.h"
 #include "gtest/gtest.h"
 #include "http/http_server.h"
 #include "http/http_status_code.h"
-#include "meta/meta_backup_service.h"
 #include "meta/meta_bulk_load_service.h"
 #include "meta/meta_data.h"
 #include "meta/meta_http_service.h"
-#include "meta/meta_service.h"
-#include "meta/meta_state_service.h"
-#include "meta_service_test_app.h"
 #include "meta_test_base.h"
-#include "rpc/rpc_holder.h"
-#include "rpc/rpc_message.h"
-#include "task/task.h"
-#include "task/task_code.h"
-#include "utils/autoref_ptr.h"
 #include "utils/blob.h"
-#include "utils/chrono_literals.h"
-#include "utils/error_code.h"
 #include "utils/fail_point.h"
 
 namespace dsn {
diff --git a/src/replica/backup/replica_backup_manager.cpp b/src/replica/backup/replica_backup_manager.cpp
index 70d8d12d45..c3f8486fe7 100644
--- a/src/replica/backup/replica_backup_manager.cpp
+++ b/src/replica/backup/replica_backup_manager.cpp
@@ -17,31 +17,11 @@
 
 #include "replica_backup_manager.h"
 
-#include <absl/strings/string_view.h>
-#include <stdint.h>
-#include <algorithm>
-#include <chrono>
-#include <map>
-#include <memory>
-#include <utility>
-#include <vector>
+#include <string_view>
 
-#include "backup_types.h"
-#include "common/gpid.h"
-#include "common/replication.codes.h"
-#include "dsn.layer2_types.h"
-#include "metadata_types.h"
-#include "replica/replica.h"
-#include "replica/replica_context.h"
-#include "replica/replication_app_base.h"
-#include "runtime/api_layer1.h"
-#include "utils/autoref_ptr.h"
-#include "utils/filesystem.h"
 #include "utils/flags.h"
-#include "utils/fmt_logging.h"
-#include "utils/strings.h"
-#include "utils/thread_access_checker.h"
 #include "utils/metrics.h"
+#include "replica/replica.h"
 
 METRIC_DEFINE_gauge_int64(replica,
                           backup_running_count,
diff --git a/src/replica/backup/replica_backup_manager.h b/src/replica/backup/replica_backup_manager.h
index 6d0f135e2c..aa941b31ef 100644
--- a/src/replica/backup/replica_backup_manager.h
+++ b/src/replica/backup/replica_backup_manager.h
@@ -17,11 +17,7 @@
 
 #pragma once
 
-#include <string>
-
 #include "replica/replica_base.h"
-#include "task/task.h"
-#include "utils/metrics.h"
 
 namespace dsn {
 
diff --git a/src/replica/replica.h b/src/replica/replica.h
index 4cd725bccb..8878ccfde0 100644
--- a/src/replica/replica.h
+++ b/src/replica/replica.h
@@ -84,9 +84,6 @@ class access_controller;
 } // namespace security
 namespace replication {
 
-class backup_request;
-class backup_response;
-
 class configuration_restore_request;
 class detect_hotkey_request;
 class detect_hotkey_response;
diff --git a/src/replica/replica_stub.cpp b/src/replica/replica_stub.cpp
index 4dc2ad719a..1f567e4c5e 100644
--- a/src/replica/replica_stub.cpp
+++ b/src/replica/replica_stub.cpp
@@ -44,7 +44,6 @@
 #include <type_traits>
 #include <vector>
 
-#include "absl/strings/string_view.h"
 #include "bulk_load/replica_bulk_loader.h"
 #include "common/backup_common.h"
 #include "common/duplication_common.h"
diff --git a/src/replica/test/replica_test.cpp b/src/replica/test/replica_test.cpp
index 6038df8c9b..3bec36cfa1 100644
--- a/src/replica/test/replica_test.cpp
+++ b/src/replica/test/replica_test.cpp
@@ -52,7 +52,6 @@
 #include "rpc/network.sim.h"
 #include "rpc/rpc_address.h"
 #include "rpc/rpc_message.h"
-#include "runtime/api_layer1.h"
 #include "task/task_code.h"
 #include "task/task_tracker.h"
 #include "test_util/test_util.h"