diff --git a/syncd/BaseRedisClient.h b/syncd/BaseRedisClient.h
new file mode 100644
index 00000000..711643a8
--- /dev/null
+++ b/syncd/BaseRedisClient.h
@@ -0,0 +1,176 @@
+#pragma once
+
+extern "C" {
+#include "saimetadata.h"
+}
+
+#include "swss/table.h"
+
+#include <string>
+#include <unordered_map>
+#include <set>
+#include <memory>
+#include <vector>
+
+namespace syncd
+{
+    class BaseRedisClient
+    {
+        public:
+
+            BaseRedisClient() = default;
+
+            virtual ~BaseRedisClient() = default;
+
+        public:
+            virtual bool isRedisEnabled() const = 0;
+
+            virtual void clearLaneMap(
+                    _In_ sai_object_id_t switchVid) const = 0;
+
+            virtual std::unordered_map<sai_uint32_t, sai_object_id_t> getLaneMap(
+                    _In_ sai_object_id_t switchVid) const = 0;
+
+            virtual void saveLaneMap(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ const std::unordered_map<sai_uint32_t, sai_object_id_t>& map) const = 0;
+
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getVidToRidMap(
+                    _In_ sai_object_id_t switchVid) const = 0;
+
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getRidToVidMap(
+                    _In_ sai_object_id_t switchVid) const = 0;
+
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getVidToRidMap() const = 0;
+
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getRidToVidMap() const = 0;
+
+            virtual void setDummyAsicStateObject(
+                    _In_ sai_object_id_t objectVid) = 0;
+
+            virtual void setDummyAsicStateObjects(
+                    _In_ size_t count,
+                    _In_ const sai_object_id_t* objectVids) = 0;
+
+            virtual void saveColdBootDiscoveredVids(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ const std::set<sai_object_id_t>& coldVids) = 0;
+
+            virtual std::shared_ptr<std::string> getSwitchHiddenAttribute(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ const std::string& attrIdName) = 0;
+
+            virtual void saveSwitchHiddenAttribute(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ const std::string& attrIdName,
+                    _In_ sai_object_id_t objectRid) = 0;
+
+            virtual std::set<sai_object_id_t> getColdVids(
+                    _In_ sai_object_id_t switchVid) = 0;
+
+            virtual void setPortLanes(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ sai_object_id_t portRid,
+                    _In_ const std::vector<uint32_t>& lanes) = 0;
+
+            virtual size_t getAsicObjectsSize(
+                    _In_ sai_object_id_t switchVid) const = 0;
+
+            virtual int removePortFromLanesMap(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ sai_object_id_t portRid) const = 0;
+
+            virtual void removeAsicObject(
+                    _In_ sai_object_id_t objectVid) const = 0;
+
+            virtual void removeAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey) = 0;
+
+            virtual void removeTempAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey) = 0;
+
+            virtual void removeAsicObjects(
+                    _In_ const std::vector<std::string>& keys) = 0;
+
+            virtual void removeTempAsicObjects(
+                    _In_ const std::vector<std::string>& keys) = 0;
+
+            virtual void createAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey,
+                    _In_ const std::vector<swss::FieldValueTuple>& attrs) = 0;
+
+            virtual void createTempAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey,
+                    _In_ const std::vector<swss::FieldValueTuple>& attrs) = 0;
+
+            virtual void createAsicObjects(
+                    _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash) = 0;
+
+            virtual void createTempAsicObjects(
+                    _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash) = 0;
+
+            virtual void setVidAndRidMap(
+                    _In_ const std::unordered_map<sai_object_id_t, sai_object_id_t>& map) = 0;
+
+            virtual std::vector<std::string> getAsicStateKeys() const = 0;
+
+            virtual std::vector<std::string> getAsicStateSwitchesKeys() const = 0;
+
+            virtual void removeColdVid(
+                    _In_ sai_object_id_t vid) = 0;
+
+            virtual std::unordered_map<std::string, std::string> getAttributesFromAsicKey(
+                    _In_ const std::string& key) const = 0;
+
+            virtual bool hasNoHiddenKeysDefined() const = 0;
+
+            virtual void removeVidAndRid(
+                    _In_ sai_object_id_t vid,
+                    _In_ sai_object_id_t rid) = 0;
+
+            virtual void insertVidAndRid(
+                    _In_ sai_object_id_t vid,
+                    _In_ sai_object_id_t rid) = 0;
+
+            virtual void insertVidsAndRids(
+                    _In_ size_t count,
+                    _In_ const sai_object_id_t* vids,
+                    _In_ const sai_object_id_t* rids) = 0;
+
+            virtual sai_object_id_t getVidForRid(
+                    _In_ sai_object_id_t rid) = 0;
+
+            virtual sai_object_id_t getRidForVid(
+                    _In_ sai_object_id_t vid) = 0;
+
+            virtual void getVidsForRids(
+                    _In_ size_t count,
+                    _In_ const sai_object_id_t* rids,
+                    _Out_ sai_object_id_t* vids) = 0;
+
+            virtual void removeAsicStateTable() = 0;
+
+            virtual void removeTempAsicStateTable() = 0;
+
+            virtual std::map<sai_object_id_t, swss::TableDump> getAsicView() = 0;
+
+            virtual std::map<sai_object_id_t, swss::TableDump> getTempAsicView() = 0;
+
+            virtual void setAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey,
+                    _In_ const std::string& attr,
+                    _In_ const std::string& value) = 0;
+
+            virtual void setTempAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey,
+                    _In_ const std::string& attr,
+                    _In_ const std::string& value) = 0;
+
+            virtual void processFlushEvent(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ sai_object_id_t portVid,
+                    _In_ sai_object_id_t bvId,
+                    _In_ sai_fdb_flush_entry_type_t type) = 0;
+    };
+}
+
diff --git a/syncd/DisabledRedisClient.cpp b/syncd/DisabledRedisClient.cpp
new file mode 100644
index 00000000..492b2ce7
--- /dev/null
+++ b/syncd/DisabledRedisClient.cpp
@@ -0,0 +1,331 @@
+#include "DisabledRedisClient.h"
+
+#include "swss/logger.h"
+
+using namespace syncd;
+
+bool DisabledRedisClient::isRedisEnabled() const
+{
+    SWSS_LOG_ENTER();
+
+    return false;
+}
+
+void DisabledRedisClient::clearLaneMap(
+        _In_ sai_object_id_t switchVid) const
+{
+    SWSS_LOG_ENTER();
+}
+
+std::unordered_map<sai_uint32_t, sai_object_id_t> DisabledRedisClient::getLaneMap(
+        _In_ sai_object_id_t switchVid) const
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+void DisabledRedisClient::saveLaneMap(
+        _In_ sai_object_id_t switchVid,
+        _In_ const std::unordered_map<sai_uint32_t, sai_object_id_t>& map) const
+{
+    SWSS_LOG_ENTER();
+}
+
+std::unordered_map<sai_object_id_t, sai_object_id_t> DisabledRedisClient::getVidToRidMap(
+        _In_ sai_object_id_t switchVid) const
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+std::unordered_map<sai_object_id_t, sai_object_id_t> DisabledRedisClient::getRidToVidMap(
+        _In_ sai_object_id_t switchVid) const
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+std::unordered_map<sai_object_id_t, sai_object_id_t> DisabledRedisClient::getVidToRidMap() const
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+std::unordered_map<sai_object_id_t, sai_object_id_t> DisabledRedisClient::getRidToVidMap() const
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+void DisabledRedisClient::setDummyAsicStateObject(
+        _In_ sai_object_id_t objectVid)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::setDummyAsicStateObjects(
+        _In_ size_t count,
+        _In_ const sai_object_id_t* objectVids)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::saveColdBootDiscoveredVids(
+        _In_ sai_object_id_t switchVid,
+        _In_ const std::set<sai_object_id_t>& coldVids)
+{
+    SWSS_LOG_ENTER();
+}
+
+std::shared_ptr<std::string> DisabledRedisClient::getSwitchHiddenAttribute(
+        _In_ sai_object_id_t switchVid,
+        _In_ const std::string& attrIdName)
+{
+    SWSS_LOG_ENTER();
+
+    return nullptr;
+}
+
+void DisabledRedisClient::saveSwitchHiddenAttribute(
+        _In_ sai_object_id_t switchVid,
+        _In_ const std::string& attrIdName,
+        _In_ sai_object_id_t objectRid)
+{
+    SWSS_LOG_ENTER();
+}
+
+std::set<sai_object_id_t> DisabledRedisClient::getColdVids(
+        _In_ sai_object_id_t switchVid)
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+void DisabledRedisClient::setPortLanes(
+        _In_ sai_object_id_t switchVid,
+        _In_ sai_object_id_t portRid,
+        _In_ const std::vector<uint32_t>& lanes)
+{
+    SWSS_LOG_ENTER();
+}
+
+size_t DisabledRedisClient::getAsicObjectsSize(
+        _In_ sai_object_id_t switchVid) const
+{
+    SWSS_LOG_ENTER();
+
+    return 0;
+}
+
+int DisabledRedisClient::removePortFromLanesMap(
+        _In_ sai_object_id_t switchVid,
+        _In_ sai_object_id_t portRid) const
+{
+    SWSS_LOG_ENTER();
+
+    return 0;
+}
+
+void DisabledRedisClient::removeAsicObject(
+        _In_ sai_object_id_t objectVid) const
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::removeAsicObject(
+        _In_ const sai_object_meta_key_t& metaKey)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::removeTempAsicObject(
+        _In_ const sai_object_meta_key_t& metaKey)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::removeAsicObjects(
+        _In_ const std::vector<std::string>& keys)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::removeTempAsicObjects(
+        _In_ const std::vector<std::string>& keys)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::createAsicObject(
+        _In_ const sai_object_meta_key_t& metaKey,
+        _In_ const std::vector<swss::FieldValueTuple>& attrs)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::createTempAsicObject(
+        _In_ const sai_object_meta_key_t& metaKey,
+        _In_ const std::vector<swss::FieldValueTuple>& attrs)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::createAsicObjects(
+        _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::createTempAsicObjects(
+        _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::setVidAndRidMap(
+        _In_ const std::unordered_map<sai_object_id_t, sai_object_id_t>& map)
+{
+    SWSS_LOG_ENTER();
+}
+
+std::vector<std::string> DisabledRedisClient::getAsicStateKeys() const
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+std::vector<std::string> DisabledRedisClient::getAsicStateSwitchesKeys() const
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+void DisabledRedisClient::removeColdVid(
+        _In_ sai_object_id_t vid)
+{
+    SWSS_LOG_ENTER();
+}
+
+std::unordered_map<std::string, std::string> DisabledRedisClient::getAttributesFromAsicKey(
+        _In_ const std::string& key) const
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+bool DisabledRedisClient::hasNoHiddenKeysDefined() const
+{
+    SWSS_LOG_ENTER();
+
+    return true;
+}
+
+void DisabledRedisClient::removeVidAndRid(
+        _In_ sai_object_id_t vid,
+        _In_ sai_object_id_t rid)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::insertVidAndRid(
+        _In_ sai_object_id_t vid,
+        _In_ sai_object_id_t rid)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::insertVidsAndRids(
+        _In_ size_t count,
+        _In_ const sai_object_id_t* vids,
+        _In_ const sai_object_id_t* rids)
+{
+    SWSS_LOG_ENTER();
+}
+
+sai_object_id_t DisabledRedisClient::getVidForRid(
+        _In_ sai_object_id_t rid)
+{
+    SWSS_LOG_ENTER();
+
+    return SAI_NULL_OBJECT_ID;
+}
+
+sai_object_id_t DisabledRedisClient::getRidForVid(
+        _In_ sai_object_id_t vid)
+{
+    SWSS_LOG_ENTER();
+
+    return SAI_NULL_OBJECT_ID;
+}
+
+void DisabledRedisClient::getVidsForRids(
+        _In_ size_t count,
+        _In_ const sai_object_id_t* rids,
+        _Out_ sai_object_id_t* vids)
+{
+    SWSS_LOG_ENTER();
+
+    for (size_t i = 0; i < count; i++)
+    {
+        vids[i] = SAI_NULL_OBJECT_ID;
+    }
+}
+
+void DisabledRedisClient::removeAsicStateTable()
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::removeTempAsicStateTable()
+{
+    SWSS_LOG_ENTER();
+}
+
+std::map<sai_object_id_t, swss::TableDump> DisabledRedisClient::getAsicView()
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+std::map<sai_object_id_t, swss::TableDump> DisabledRedisClient::getTempAsicView()
+{
+    SWSS_LOG_ENTER();
+
+    return {};
+}
+
+void DisabledRedisClient::setAsicObject(
+        _In_ const sai_object_meta_key_t& metaKey,
+        _In_ const std::string& attr,
+        _In_ const std::string& value)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::setTempAsicObject(
+        _In_ const sai_object_meta_key_t& metaKey,
+        _In_ const std::string& attr,
+        _In_ const std::string& value)
+{
+    SWSS_LOG_ENTER();
+}
+
+void DisabledRedisClient::processFlushEvent(
+        _In_ sai_object_id_t switchVid,
+        _In_ sai_object_id_t portVid,
+        _In_ sai_object_id_t bvId,
+        _In_ sai_fdb_flush_entry_type_t type)
+{
+    SWSS_LOG_ENTER();
+}
+
diff --git a/syncd/DisabledRedisClient.h b/syncd/DisabledRedisClient.h
new file mode 100644
index 00000000..100ee842
--- /dev/null
+++ b/syncd/DisabledRedisClient.h
@@ -0,0 +1,166 @@
+#pragma once
+
+#include "BaseRedisClient.h"
+
+namespace syncd
+{
+    class DisabledRedisClient: public BaseRedisClient
+    {
+        public:
+
+            DisabledRedisClient() = default;
+
+            virtual ~DisabledRedisClient() = default;
+
+        public:
+            virtual bool isRedisEnabled() const override;
+
+            virtual void clearLaneMap(
+                    _In_ sai_object_id_t switchVid) const override;
+
+            virtual std::unordered_map<sai_uint32_t, sai_object_id_t> getLaneMap(
+                    _In_ sai_object_id_t switchVid) const override;
+
+            virtual void saveLaneMap(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ const std::unordered_map<sai_uint32_t, sai_object_id_t>& map) const override;
+
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getVidToRidMap(
+                    _In_ sai_object_id_t switchVid) const override;
+
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getRidToVidMap(
+                    _In_ sai_object_id_t switchVid) const override;
+
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getVidToRidMap() const override;
+
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getRidToVidMap() const override;
+
+            virtual void setDummyAsicStateObject(
+                    _In_ sai_object_id_t objectVid) override;
+
+            virtual void setDummyAsicStateObjects(
+                    _In_ size_t count,
+                    _In_ const sai_object_id_t* objectVids) override;
+
+            virtual void saveColdBootDiscoveredVids(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ const std::set<sai_object_id_t>& coldVids) override;
+
+            virtual std::shared_ptr<std::string> getSwitchHiddenAttribute(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ const std::string& attrIdName) override;
+
+            virtual void saveSwitchHiddenAttribute(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ const std::string& attrIdName,
+                    _In_ sai_object_id_t objectRid) override;
+
+            virtual std::set<sai_object_id_t> getColdVids(
+                    _In_ sai_object_id_t switchVid) override;
+
+            virtual void setPortLanes(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ sai_object_id_t portRid,
+                    _In_ const std::vector<uint32_t>& lanes) override;
+
+            virtual size_t getAsicObjectsSize(
+                    _In_ sai_object_id_t switchVid) const override;
+
+            virtual int removePortFromLanesMap(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ sai_object_id_t portRid) const override;
+
+            virtual void removeAsicObject(
+                    _In_ sai_object_id_t objectVid) const override;
+
+            virtual void removeAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey) override;
+
+            virtual void removeTempAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey) override;
+
+            virtual void removeAsicObjects(
+                    _In_ const std::vector<std::string>& keys) override;
+
+            virtual void removeTempAsicObjects(
+                    _In_ const std::vector<std::string>& keys) override;
+
+            virtual void createAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey,
+                    _In_ const std::vector<swss::FieldValueTuple>& attrs) override;
+
+            virtual void createTempAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey,
+                    _In_ const std::vector<swss::FieldValueTuple>& attrs) override;
+
+            virtual void createAsicObjects(
+                    _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash) override;
+
+            virtual void createTempAsicObjects(
+                    _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash) override;
+
+            virtual void setVidAndRidMap(
+                    _In_ const std::unordered_map<sai_object_id_t, sai_object_id_t>& map) override;
+
+            virtual std::vector<std::string> getAsicStateKeys() const override;
+
+            virtual std::vector<std::string> getAsicStateSwitchesKeys() const override;
+
+            virtual void removeColdVid(
+                    _In_ sai_object_id_t vid) override;
+
+            virtual std::unordered_map<std::string, std::string> getAttributesFromAsicKey(
+                    _In_ const std::string& key) const override;
+
+            virtual bool hasNoHiddenKeysDefined() const override;
+
+            virtual void removeVidAndRid(
+                    _In_ sai_object_id_t vid,
+                    _In_ sai_object_id_t rid) override;
+
+            virtual void insertVidAndRid(
+                    _In_ sai_object_id_t vid,
+                    _In_ sai_object_id_t rid) override;
+
+            virtual void insertVidsAndRids(
+                    _In_ size_t count,
+                    _In_ const sai_object_id_t* vids,
+                    _In_ const sai_object_id_t* rids) override;
+
+            virtual sai_object_id_t getVidForRid(
+                    _In_ sai_object_id_t rid) override;
+
+            virtual sai_object_id_t getRidForVid(
+                    _In_ sai_object_id_t vid) override;
+
+            virtual void getVidsForRids(
+                    _In_ size_t count,
+                    _In_ const sai_object_id_t* rids,
+                    _Out_ sai_object_id_t* vids) override;
+
+            virtual void removeAsicStateTable() override;
+
+            virtual void removeTempAsicStateTable() override;
+
+            virtual std::map<sai_object_id_t, swss::TableDump> getAsicView() override;
+
+            virtual std::map<sai_object_id_t, swss::TableDump> getTempAsicView() override;
+
+            virtual void setAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey,
+                    _In_ const std::string& attr,
+                    _In_ const std::string& value) override;
+
+            virtual void setTempAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey,
+                    _In_ const std::string& attr,
+                    _In_ const std::string& value) override;
+
+            virtual void processFlushEvent(
+                    _In_ sai_object_id_t switchVid,
+                    _In_ sai_object_id_t portVid,
+                    _In_ sai_object_id_t bvId,
+                    _In_ sai_fdb_flush_entry_type_t type) override;
+    };
+}
+
diff --git a/syncd/HardReiniter.cpp b/syncd/HardReiniter.cpp
index 8c714eb2..570dc69f 100644
--- a/syncd/HardReiniter.cpp
+++ b/syncd/HardReiniter.cpp
@@ -1,7 +1,7 @@
 #include "HardReiniter.h"
 #include "VidManager.h"
 #include "SingleReiniter.h"
-#include "RedisClient.h"
+#include "BaseRedisClient.h"
 
 #include "swss/logger.h"
 
@@ -10,7 +10,7 @@
 using namespace syncd;
 
 HardReiniter::HardReiniter(
-        _In_ std::shared_ptr<RedisClient> client,
+        _In_ std::shared_ptr<BaseRedisClient> client,
         _In_ std::shared_ptr<VirtualOidTranslator> translator,
         _In_ std::shared_ptr<sairedis::SaiInterface> sai,
         _In_ std::shared_ptr<NotificationHandler> handler):
diff --git a/syncd/HardReiniter.h b/syncd/HardReiniter.h
index 9a032d16..0c3bf2e7 100644
--- a/syncd/HardReiniter.h
+++ b/syncd/HardReiniter.h
@@ -3,7 +3,7 @@
 #include "meta/SaiInterface.h"
 #include "SaiSwitch.h"
 #include "VirtualOidTranslator.h"
-#include "RedisClient.h"
+#include "BaseRedisClient.h"
 #include "NotificationHandler.h"
 
 #include <string>
@@ -24,7 +24,7 @@ namespace syncd
         public:
 
             HardReiniter(
-                    _In_ std::shared_ptr<RedisClient> client,
+                    _In_ std::shared_ptr<BaseRedisClient> client,
                     _In_ std::shared_ptr<VirtualOidTranslator> translator,
                     _In_ std::shared_ptr<sairedis::SaiInterface> sai,
                     _In_ std::shared_ptr<NotificationHandler> handler);
@@ -56,7 +56,7 @@ namespace syncd
 
             std::shared_ptr<VirtualOidTranslator> m_translator;
 
-            std::shared_ptr<RedisClient> m_client;
+            std::shared_ptr<BaseRedisClient> m_client;
 
             std::shared_ptr<NotificationHandler> m_handler;
     };
diff --git a/syncd/Makefile.am b/syncd/Makefile.am
index 271fb299..39d03cba 100644
--- a/syncd/Makefile.am
+++ b/syncd/Makefile.am
@@ -24,6 +24,7 @@ libSyncd_a_SOURCES = \
 				CommandLineOptions.cpp \
 				CommandLineOptionsParser.cpp \
 				ComparisonLogic.cpp \
+				DisabledRedisClient.cpp \
 				FlexCounter.cpp \
 				FlexCounterManager.cpp \
 				GlobalSwitchId.cpp \
diff --git a/syncd/NotificationProcessor.cpp b/syncd/NotificationProcessor.cpp
index bc8399fd..eb688b21 100644
--- a/syncd/NotificationProcessor.cpp
+++ b/syncd/NotificationProcessor.cpp
@@ -1,5 +1,5 @@
 #include "NotificationProcessor.h"
-#include "RedisClient.h"
+#include "BaseRedisClient.h"
 
 #include "sairediscommon.h"
 
@@ -16,7 +16,7 @@ using namespace saimeta;
 
 NotificationProcessor::NotificationProcessor(
         _In_ std::shared_ptr<NotificationProducerBase> producer,
-        _In_ std::shared_ptr<RedisClient> client,
+        _In_ std::shared_ptr<BaseRedisClient> client,
         _In_ std::function<void(const swss::KeyOpFieldsValuesTuple&)> synchronizer):
     m_synchronizer(synchronizer),
     m_client(client),
diff --git a/syncd/NotificationProcessor.h b/syncd/NotificationProcessor.h
index 751442ce..0109edd5 100644
--- a/syncd/NotificationProcessor.h
+++ b/syncd/NotificationProcessor.h
@@ -2,7 +2,7 @@
 
 #include "NotificationQueue.h"
 #include "VirtualOidTranslator.h"
-#include "RedisClient.h"
+#include "BaseRedisClient.h"
 #include "NotificationProducerBase.h"
 
 #include "swss/notificationproducer.h"
@@ -20,7 +20,7 @@ namespace syncd
 
             NotificationProcessor(
                     _In_ std::shared_ptr<NotificationProducerBase> producer,
-                    _In_ std::shared_ptr<RedisClient> client,
+                    _In_ std::shared_ptr<BaseRedisClient> client,
                     _In_ std::function<void(const swss::KeyOpFieldsValuesTuple&)> synchronizer);
 
             virtual ~NotificationProcessor();
@@ -197,7 +197,7 @@ namespace syncd
 
             std::function<void(const swss::KeyOpFieldsValuesTuple&)> m_synchronizer;
 
-            std::shared_ptr<RedisClient> m_client;
+            std::shared_ptr<BaseRedisClient> m_client;
 
             std::shared_ptr<NotificationProducerBase> m_notifications;
     };
diff --git a/syncd/RedisClient.cpp b/syncd/RedisClient.cpp
index 6a0e3964..4f4c4791 100644
--- a/syncd/RedisClient.cpp
+++ b/syncd/RedisClient.cpp
@@ -37,6 +37,13 @@ RedisClient::~RedisClient()
     // empty
 }
 
+bool RedisClient::isRedisEnabled() const
+{
+    SWSS_LOG_ENTER();
+
+    return true;
+}
+
 std::string RedisClient::getRedisLanesKey(
         _In_ sai_object_id_t switchVid) const
 {
diff --git a/syncd/RedisClient.h b/syncd/RedisClient.h
index a5bd76b2..cdc467b9 100644
--- a/syncd/RedisClient.h
+++ b/syncd/RedisClient.h
@@ -1,10 +1,8 @@
 #pragma once
 
-extern "C" {
-#include "saimetadata.h"
-}
+#include "BaseRedisClient.h"
 
-#include "swss/table.h"
+#include "swss/dbconnector.h"
 
 #include <string>
 #include <unordered_map>
@@ -14,7 +12,7 @@ extern "C" {
 
 namespace syncd
 {
-    class RedisClient
+    class RedisClient: public BaseRedisClient
     {
         public:
 
@@ -25,152 +23,154 @@ namespace syncd
 
         public:
 
-            void clearLaneMap(
-                    _In_ sai_object_id_t switchVid) const;
+            virtual bool isRedisEnabled() const override;
 
-            std::unordered_map<sai_uint32_t, sai_object_id_t> getLaneMap(
-                    _In_ sai_object_id_t switchVid) const;
+            virtual void clearLaneMap(
+                    _In_ sai_object_id_t switchVid) const override;
 
-            void saveLaneMap(
+            virtual std::unordered_map<sai_uint32_t, sai_object_id_t> getLaneMap(
+                    _In_ sai_object_id_t switchVid) const override;
+
+            virtual void saveLaneMap(
                     _In_ sai_object_id_t switchVid,
-                    _In_ const std::unordered_map<sai_uint32_t, sai_object_id_t>& map) const;
+                    _In_ const std::unordered_map<sai_uint32_t, sai_object_id_t>& map) const override;
 
-            std::unordered_map<sai_object_id_t, sai_object_id_t> getVidToRidMap(
-                    _In_ sai_object_id_t switchVid) const;
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getVidToRidMap(
+                    _In_ sai_object_id_t switchVid) const override;
 
-            std::unordered_map<sai_object_id_t, sai_object_id_t> getRidToVidMap(
-                    _In_ sai_object_id_t switchVid) const;
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getRidToVidMap(
+                    _In_ sai_object_id_t switchVid) const override;
 
-            std::unordered_map<sai_object_id_t, sai_object_id_t> getVidToRidMap() const;
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getVidToRidMap() const override;
 
-            std::unordered_map<sai_object_id_t, sai_object_id_t> getRidToVidMap() const;
+            virtual std::unordered_map<sai_object_id_t, sai_object_id_t> getRidToVidMap() const override;
 
-            void setDummyAsicStateObject(
-                    _In_ sai_object_id_t objectVid);
+            virtual void setDummyAsicStateObject(
+                    _In_ sai_object_id_t objectVid) override;
 
-            void setDummyAsicStateObjects(
+            virtual void setDummyAsicStateObjects(
                     _In_ size_t count,
-                    _In_ const sai_object_id_t* objectVids);
+                    _In_ const sai_object_id_t* objectVids) override;
 
-            void saveColdBootDiscoveredVids(
+            virtual void saveColdBootDiscoveredVids(
                     _In_ sai_object_id_t switchVid,
-                    _In_ const std::set<sai_object_id_t>& coldVids);
+                    _In_ const std::set<sai_object_id_t>& coldVids) override;
 
-            std::shared_ptr<std::string> getSwitchHiddenAttribute(
+            virtual std::shared_ptr<std::string> getSwitchHiddenAttribute(
                     _In_ sai_object_id_t switchVid,
-                    _In_ const std::string& attrIdName);
+                    _In_ const std::string& attrIdName) override;
 
-            void saveSwitchHiddenAttribute(
+            virtual void saveSwitchHiddenAttribute(
                     _In_ sai_object_id_t switchVid,
                     _In_ const std::string& attrIdName,
-                    _In_ sai_object_id_t objectRid);
+                    _In_ sai_object_id_t objectRid) override;
 
-            std::set<sai_object_id_t> getColdVids(
-                    _In_ sai_object_id_t switchVid);
+            virtual std::set<sai_object_id_t> getColdVids(
+                    _In_ sai_object_id_t switchVid) override;
 
-            void setPortLanes(
+            virtual void setPortLanes(
                     _In_ sai_object_id_t switchVid,
                     _In_ sai_object_id_t portRid,
-                    _In_ const std::vector<uint32_t>& lanes);
+                    _In_ const std::vector<uint32_t>& lanes) override;
 
-            size_t getAsicObjectsSize(
-                    _In_ sai_object_id_t switchVid) const;
+            virtual size_t getAsicObjectsSize(
+                    _In_ sai_object_id_t switchVid) const override;
 
-            int removePortFromLanesMap(
+            virtual int removePortFromLanesMap(
                     _In_ sai_object_id_t switchVid,
-                    _In_ sai_object_id_t portRid) const;
+                    _In_ sai_object_id_t portRid) const override;
 
-            void removeAsicObject(
-                    _In_ sai_object_id_t objectVid) const;
+            virtual void removeAsicObject(
+                    _In_ sai_object_id_t objectVid) const override;
 
-            void removeAsicObject(
-                    _In_ const sai_object_meta_key_t& metaKey);
+            virtual void removeAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey) override;
 
-            void removeTempAsicObject(
-                    _In_ const sai_object_meta_key_t& metaKey);
+            virtual void removeTempAsicObject(
+                    _In_ const sai_object_meta_key_t& metaKey) override;
 
-            void removeAsicObjects(
-                    _In_ const std::vector<std::string>& keys);
+            virtual void removeAsicObjects(
+                    _In_ const std::vector<std::string>& keys) override;
 
-            void removeTempAsicObjects(
-                    _In_ const std::vector<std::string>& keys);
+            virtual void removeTempAsicObjects(
+                    _In_ const std::vector<std::string>& keys) override;
 
-            void createAsicObject(
+            virtual void createAsicObject(
                     _In_ const sai_object_meta_key_t& metaKey,
-                    _In_ const std::vector<swss::FieldValueTuple>& attrs);
+                    _In_ const std::vector<swss::FieldValueTuple>& attrs) override;
 
-            void createTempAsicObject(
+            virtual void createTempAsicObject(
                     _In_ const sai_object_meta_key_t& metaKey,
-                    _In_ const std::vector<swss::FieldValueTuple>& attrs);
+                    _In_ const std::vector<swss::FieldValueTuple>& attrs) override;
 
-            void createAsicObjects(
-                    _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash);
+            virtual void createAsicObjects(
+                    _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash) override;
 
-            void createTempAsicObjects(
-                    _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash);
+            virtual void createTempAsicObjects(
+                    _In_ const std::unordered_map<std::string, std::vector<swss::FieldValueTuple>>& multiHash) override;
 
-            void setVidAndRidMap(
-                    _In_ const std::unordered_map<sai_object_id_t, sai_object_id_t>& map);
+            virtual void setVidAndRidMap(
+                    _In_ const std::unordered_map<sai_object_id_t, sai_object_id_t>& map) override;
 
-            std::vector<std::string> getAsicStateKeys() const;
+            virtual std::vector<std::string> getAsicStateKeys() const override;
 
-            std::vector<std::string> getAsicStateSwitchesKeys() const;
+            virtual std::vector<std::string> getAsicStateSwitchesKeys() const override;
 
-            void removeColdVid(
-                    _In_ sai_object_id_t vid);
+            virtual void removeColdVid(
+                    _In_ sai_object_id_t vid) override;
 
-            std::unordered_map<std::string, std::string> getAttributesFromAsicKey(
-                    _In_ const std::string& key) const;
+            virtual std::unordered_map<std::string, std::string> getAttributesFromAsicKey(
+                    _In_ const std::string& key) const override;
 
-            bool hasNoHiddenKeysDefined() const;
+            virtual bool hasNoHiddenKeysDefined() const override;
 
-            void removeVidAndRid(
+            virtual void removeVidAndRid(
                     _In_ sai_object_id_t vid,
-                    _In_ sai_object_id_t rid);
+                    _In_ sai_object_id_t rid) override;
 
-            void insertVidAndRid(
+            virtual void insertVidAndRid(
                     _In_ sai_object_id_t vid,
-                    _In_ sai_object_id_t rid);
+                    _In_ sai_object_id_t rid) override;
 
-            void insertVidsAndRids(
+            virtual void insertVidsAndRids(
                     _In_ size_t count,
                     _In_ const sai_object_id_t* vids,
-                    _In_ const sai_object_id_t* rids);
+                    _In_ const sai_object_id_t* rids) override;
 
-            sai_object_id_t getVidForRid(
-                    _In_ sai_object_id_t rid);
+            virtual sai_object_id_t getVidForRid(
+                    _In_ sai_object_id_t rid) override;
 
-            sai_object_id_t getRidForVid(
-                    _In_ sai_object_id_t vid);
+            virtual sai_object_id_t getRidForVid(
+                    _In_ sai_object_id_t vid) override;
 
-            void getVidsForRids(
+            virtual void getVidsForRids(
                     _In_ size_t count,
                     _In_ const sai_object_id_t* rids,
-                    _Out_ sai_object_id_t* vids);
+                    _Out_ sai_object_id_t* vids) override;
 
-            void removeAsicStateTable();
+            virtual void removeAsicStateTable() override;
 
-            void removeTempAsicStateTable();
+            virtual void removeTempAsicStateTable() override;
 
-            std::map<sai_object_id_t, swss::TableDump> getAsicView();
+            virtual std::map<sai_object_id_t, swss::TableDump> getAsicView() override;
 
-            std::map<sai_object_id_t, swss::TableDump> getTempAsicView();
+            virtual std::map<sai_object_id_t, swss::TableDump> getTempAsicView() override;
 
-            void setAsicObject(
+            virtual void setAsicObject(
                     _In_ const sai_object_meta_key_t& metaKey,
                     _In_ const std::string& attr,
-                    _In_ const std::string& value);
+                    _In_ const std::string& value) override;
 
-            void setTempAsicObject(
+            virtual void setTempAsicObject(
                     _In_ const sai_object_meta_key_t& metaKey,
                     _In_ const std::string& attr,
-                    _In_ const std::string& value);
+                    _In_ const std::string& value) override;
 
-            void processFlushEvent(
+            virtual void processFlushEvent(
                     _In_ sai_object_id_t switchVid,
                     _In_ sai_object_id_t portVid,
                     _In_ sai_object_id_t bvId,
-                    _In_ sai_fdb_flush_entry_type_t type);
+                    _In_ sai_fdb_flush_entry_type_t type) override;
 
         private:
 
@@ -194,6 +194,5 @@ namespace syncd
             std::shared_ptr<swss::DBConnector> m_dbAsic;
 
             std::string m_fdbFlushSha;
-
     };
 }
diff --git a/syncd/SaiSwitch.cpp b/syncd/SaiSwitch.cpp
index d862a8c5..f0ed58a7 100644
--- a/syncd/SaiSwitch.cpp
+++ b/syncd/SaiSwitch.cpp
@@ -4,6 +4,7 @@
 #include "VidManager.h"
 #include "GlobalSwitchId.h"
 #include "RedisClient.h"
+#include "DisabledRedisClient.h"
 
 #include "meta/sai_serialize.h"
 #include "swss/logger.h"
@@ -23,7 +24,7 @@ using namespace syncd;
 SaiSwitch::SaiSwitch(
         _In_ sai_object_id_t switch_vid,
         _In_ sai_object_id_t switch_rid,
-        _In_ std::shared_ptr<RedisClient> client,
+        _In_ std::shared_ptr<BaseRedisClient> client,
         _In_ std::shared_ptr<VirtualOidTranslator> translator,
         _In_ std::shared_ptr<sairedis::SaiInterface> vendorSai,
         _In_ bool warmBoot):
@@ -1152,6 +1153,12 @@ void SaiSwitch::postPortRemove(
 
         if (vid == SAI_NULL_OBJECT_ID)
         {
+            if (!m_client->isRedisEnabled())
+            {
+                SWSS_LOG_DEBUG("Redis disabled, skipping rid %s removal from RIDTOVID",
+                        sai_serialize_object_id(rid).c_str());
+                continue;
+            }
             SWSS_LOG_THROW("expected rid %s to be present in RIDTOVID",
                     sai_serialize_object_id(rid).c_str());
         }
@@ -1171,7 +1178,7 @@ void SaiSwitch::postPortRemove(
             removed,
             sai_serialize_object_id(portRid).c_str());
 
-    if (removed == 0)
+    if (removed == 0 && m_client->isRedisEnabled())
     {
         SWSS_LOG_THROW("NO LANES found in redis lane map for given port RID %s",
                 sai_serialize_object_id(portRid).c_str());
diff --git a/syncd/SaiSwitch.h b/syncd/SaiSwitch.h
index c0a36233..262f20e8 100644
--- a/syncd/SaiSwitch.h
+++ b/syncd/SaiSwitch.h
@@ -6,7 +6,7 @@ extern "C" {
 
 #include "meta/SaiInterface.h"
 #include "VirtualOidTranslator.h"
-#include "RedisClient.h"
+#include "BaseRedisClient.h"
 #include "SaiSwitchInterface.h"
 
 #include <set>
@@ -31,7 +31,7 @@ namespace syncd
             SaiSwitch(
                     _In_ sai_object_id_t switch_vid,
                     _In_ sai_object_id_t switch_rid,
-                    _In_ std::shared_ptr<RedisClient> client,
+                    _In_ std::shared_ptr<BaseRedisClient> client,
                     _In_ std::shared_ptr<VirtualOidTranslator> translator,
                     _In_ std::shared_ptr<sairedis::SaiInterface> vendorSai,
                     _In_ bool warmBoot);
@@ -377,6 +377,6 @@ namespace syncd
 
             std::shared_ptr<VirtualOidTranslator> m_translator;
 
-            std::shared_ptr<RedisClient> m_client;
+            std::shared_ptr<BaseRedisClient> m_client;
     };
 }
diff --git a/syncd/SingleReiniter.cpp b/syncd/SingleReiniter.cpp
index 6f535573..eeea4b14 100644
--- a/syncd/SingleReiniter.cpp
+++ b/syncd/SingleReiniter.cpp
@@ -3,7 +3,7 @@
 #include "CommandLineOptions.h"
 #include "NotificationHandler.h"
 #include "Workaround.h"
-#include "RedisClient.h"
+#include "BaseRedisClient.h"
 
 #include "swss/logger.h"
 
@@ -16,7 +16,7 @@ using namespace syncd;
 using namespace saimeta;
 
 SingleReiniter::SingleReiniter(
-        _In_ std::shared_ptr<RedisClient> client,
+        _In_ std::shared_ptr<BaseRedisClient> client,
         _In_ std::shared_ptr<VirtualOidTranslator> translator,
         _In_ std::shared_ptr<sairedis::SaiInterface> sai,
         _In_ std::shared_ptr<NotificationHandler> handler,
diff --git a/syncd/SingleReiniter.h b/syncd/SingleReiniter.h
index e33b26af..81abe820 100644
--- a/syncd/SingleReiniter.h
+++ b/syncd/SingleReiniter.h
@@ -2,7 +2,7 @@
 
 #include "SaiSwitch.h"
 #include "VirtualOidTranslator.h"
-#include "RedisClient.h"
+#include "BaseRedisClient.h"
 #include "NotificationHandler.h"
 
 #include "meta/SaiInterface.h"
@@ -26,7 +26,7 @@ namespace syncd
         public:
 
             SingleReiniter(
-                    _In_ std::shared_ptr<RedisClient> client,
+                    _In_ std::shared_ptr<BaseRedisClient> client,
                     _In_ std::shared_ptr<VirtualOidTranslator> translator,
                     _In_ std::shared_ptr<sairedis::SaiInterface> sai,
                     _In_ std::shared_ptr<NotificationHandler> handler,
@@ -133,7 +133,7 @@ namespace syncd
 
             std::shared_ptr<VirtualOidTranslator> m_translator;
 
-            std::shared_ptr<RedisClient> m_client;
+            std::shared_ptr<BaseRedisClient> m_client;
 
             std::shared_ptr<NotificationHandler> m_handler;
     };
diff --git a/syncd/Syncd.cpp b/syncd/Syncd.cpp
index 64e05419..1aeec2ee 100644
--- a/syncd/Syncd.cpp
+++ b/syncd/Syncd.cpp
@@ -5,6 +5,7 @@
 #include "ComparisonLogic.h"
 #include "HardReiniter.h"
 #include "RedisClient.h"
+#include "DisabledRedisClient.h"
 #include "RequestShutdown.h"
 #include "WarmRestartTable.h"
 #include "ContextConfigContainer.h"
@@ -152,7 +153,16 @@ Syncd::Syncd(
                 modifyRedis);
     }
 
-    m_client = std::make_shared<RedisClient>(m_dbAsic);
+    bool isVirtualSwitch = m_profileMap.find(SAI_KEY_VS_SWITCH_TYPE) != m_profileMap.end();
+
+    if (m_contextConfig->m_zmqEnable && !isVirtualSwitch)
+    {
+        m_client = std::make_shared<DisabledRedisClient>();
+    }
+    else
+    {
+        m_client = std::make_shared<RedisClient>(m_dbAsic);
+    }
 
     m_processor = std::make_shared<NotificationProcessor>(m_notifications, m_client, std::bind(&Syncd::syncProcessNotification, this, _1));
     m_handler = std::make_shared<NotificationHandler>(m_processor);
diff --git a/syncd/Syncd.h b/syncd/Syncd.h
index bd59fcc2..e8942d78 100644
--- a/syncd/Syncd.h
+++ b/syncd/Syncd.h
@@ -6,7 +6,7 @@
 #include "AsicView.h"
 #include "SaiSwitch.h"
 #include "VirtualOidTranslator.h"
-#include "RedisClient.h"
+#include "BaseRedisClient.h"
 #include "NotificationHandler.h"
 #include "NotificationProcessor.h"
 #include "SwitchNotifications.h"
@@ -477,7 +477,7 @@ namespace syncd
 
             std::shared_ptr<VirtualOidTranslator> m_translator;
 
-            std::shared_ptr<RedisClient> m_client;
+            std::shared_ptr<BaseRedisClient> m_client;
 
             std::shared_ptr<NotificationHandler> m_handler;
 
diff --git a/syncd/VirtualOidTranslator.cpp b/syncd/VirtualOidTranslator.cpp
index f79d6754..3032c5cc 100644
--- a/syncd/VirtualOidTranslator.cpp
+++ b/syncd/VirtualOidTranslator.cpp
@@ -1,6 +1,7 @@
 #include "VirtualOidTranslator.h"
 #include "VirtualObjectIdManager.h"
 #include "RedisClient.h"
+#include "DisabledRedisClient.h"
 
 #include "swss/logger.h"
 #include "meta/sai_serialize.h"
@@ -10,7 +11,7 @@
 using namespace syncd;
 
 VirtualOidTranslator::VirtualOidTranslator(
-        _In_ std::shared_ptr<RedisClient> client,
+        _In_ std::shared_ptr<BaseRedisClient> client,
         _In_ std::shared_ptr<sairedis::VirtualObjectIdManager> virtualObjectIdManager,
         _In_ std::shared_ptr<sairedis::SaiInterface> vendorSai):
     m_virtualObjectIdManager(virtualObjectIdManager),
@@ -366,6 +367,13 @@ sai_object_id_t VirtualOidTranslator::translateVidToRid(
 
     if (rid == SAI_NULL_OBJECT_ID)
     {
+        if (!m_client->isRedisEnabled())
+        {
+            SWSS_LOG_DEBUG("Redis disabled, unable to get RID for VID %s",
+                    sai_serialize_object_id(vid).c_str());
+            return SAI_NULL_OBJECT_ID;
+        }
+
             /*
              * If user created object that is object id, then it should not
              * query attributes of this object in init view mode, because he
diff --git a/syncd/VirtualOidTranslator.h b/syncd/VirtualOidTranslator.h
index e6e290c4..ceb2a0a6 100644
--- a/syncd/VirtualOidTranslator.h
+++ b/syncd/VirtualOidTranslator.h
@@ -5,7 +5,7 @@ extern "C"{
 }
 
 #include "VirtualObjectIdManager.h"
-#include "RedisClient.h"
+#include "BaseRedisClient.h"
 
 #include "meta/SaiInterface.h"
 
@@ -22,7 +22,7 @@ namespace syncd
         public:
 
             VirtualOidTranslator(
-                    _In_ std::shared_ptr<RedisClient> client,
+                    _In_ std::shared_ptr<BaseRedisClient> client,
                     _In_ std::shared_ptr<sairedis::VirtualObjectIdManager> virtualObjectIdManager,
                     _In_ std::shared_ptr<sairedis::SaiInterface> vendorSai);
 
@@ -142,6 +142,6 @@ namespace syncd
             std::unordered_map<sai_object_id_t, sai_object_id_t> m_vid2rid;
             std::unordered_map<sai_object_id_t, sai_object_id_t> m_removedRid2vid;
 
-            std::shared_ptr<RedisClient> m_client;
+            std::shared_ptr<BaseRedisClient> m_client;
     };
 }
diff --git a/syncd/tests/Makefile.am b/syncd/tests/Makefile.am
index e63925e7..62cf934c 100644
--- a/syncd/tests/Makefile.am
+++ b/syncd/tests/Makefile.am
@@ -5,7 +5,7 @@ LDADD_GTEST = -L/usr/src/gtest -lgtest -lgtest_main
 bin_PROGRAMS = tests
 
 tests_SOURCES = \
-    main.cpp TestSyncdBrcm.cpp TestSyncdMlnx.cpp TestSyncdNvdaBf.cpp TestSyncdLib.cpp
+    main.cpp TestSyncdBrcm.cpp TestSyncdMlnx.cpp TestSyncdNvdaBf.cpp TestSyncdLib.cpp TestDisabledRedisClient.cpp
 tests_CXXFLAGS = \
     $(DBGFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS_COMMON)
 tests_LDADD = \
diff --git a/syncd/tests/TestDisabledRedisClient.cpp b/syncd/tests/TestDisabledRedisClient.cpp
new file mode 100644
index 00000000..0734e05a
--- /dev/null
+++ b/syncd/tests/TestDisabledRedisClient.cpp
@@ -0,0 +1,231 @@
+#include <gtest/gtest.h>
+#include <memory>
+
+#include <swss/dbconnector.h>
+
+#include "DisabledRedisClient.h"
+#include "BaseRedisClient.h"
+
+using namespace syncd;
+
+class DisabledRedisClientTest : public ::testing::Test
+{
+public:
+    DisabledRedisClientTest() = default;
+    virtual ~DisabledRedisClientTest() = default;
+
+public:
+    virtual void SetUp() override
+    {
+        m_redisClient = std::make_shared<DisabledRedisClient>();
+    }
+
+    virtual void TearDown() override
+    {
+        m_redisClient.reset();
+        m_dbAsic.reset();
+    }
+
+protected:
+    std::shared_ptr<swss::DBConnector> m_dbAsic;
+    std::shared_ptr<BaseRedisClient> m_redisClient;
+};
+
+TEST_F(DisabledRedisClientTest, isRedisEnabledReturnsFalse)
+{
+    auto result = m_redisClient->isRedisEnabled();
+    EXPECT_FALSE(result);
+}
+
+TEST_F(DisabledRedisClientTest, hasNoHiddenKeysDefinedReturnsTrue)
+{
+    auto result = m_redisClient->hasNoHiddenKeysDefined();
+    EXPECT_TRUE(result);
+}
+
+TEST_F(DisabledRedisClientTest, removeAsicObjectsDoesNotThrow)
+{
+    std::vector<std::string> keys = {"key1", "key2"};
+    EXPECT_NO_THROW(m_redisClient->removeAsicObjects(keys));
+}
+
+TEST_F(DisabledRedisClientTest, getLaneMapReturnsEmpty)
+{
+    sai_object_id_t switchVid = 0x21000000000000;
+    auto result = m_redisClient->getLaneMap(switchVid);
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getVidToRidMapWithSwitchVidReturnsEmpty)
+{
+    sai_object_id_t switchVid = 0x21000000000000;
+    auto result = m_redisClient->getVidToRidMap(switchVid);
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getRidToVidMapWithSwitchVidReturnsEmpty)
+{
+    sai_object_id_t switchVid = 0x21000000000000;
+    auto result = m_redisClient->getRidToVidMap(switchVid);
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getVidToRidMapReturnsEmpty)
+{
+    auto result = m_redisClient->getVidToRidMap();
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getRidToVidMapReturnsEmpty)
+{
+    auto result = m_redisClient->getRidToVidMap();
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getColdVidsReturnsEmpty)
+{
+    sai_object_id_t switchVid = 0x21000000000000;
+    auto result = m_redisClient->getColdVids(switchVid);
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getAsicObjectsSizeReturnsZero)
+{
+    sai_object_id_t switchVid = 0x21000000000000;
+    auto result = m_redisClient->getAsicObjectsSize(switchVid);
+    EXPECT_EQ(result, 0);
+}
+
+TEST_F(DisabledRedisClientTest, removePortFromLanesMapReturnsZero)
+{
+    sai_object_id_t switchVid = 0x21000000000000;
+    sai_object_id_t portRid = 0x10000000000001;
+    auto result = m_redisClient->removePortFromLanesMap(switchVid, portRid);
+    EXPECT_EQ(result, 0);
+}
+
+TEST_F(DisabledRedisClientTest, getAsicStateKeysReturnsEmpty)
+{
+    auto result = m_redisClient->getAsicStateKeys();
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getAsicStateSwitchesKeysReturnsEmpty)
+{
+    auto result = m_redisClient->getAsicStateSwitchesKeys();
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getAttributesFromAsicKeyReturnsEmpty)
+{
+    auto result = m_redisClient->getAttributesFromAsicKey("somekey");
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getVidForRidReturnsNullObjectId)
+{
+    sai_object_id_t rid = 0x10000000000001;
+    auto result = m_redisClient->getVidForRid(rid);
+    EXPECT_EQ(result, SAI_NULL_OBJECT_ID);
+}
+
+TEST_F(DisabledRedisClientTest, getRidForVidReturnsNullObjectId)
+{
+    sai_object_id_t vid = 0x21000000000001;
+    auto result = m_redisClient->getRidForVid(vid);
+    EXPECT_EQ(result, SAI_NULL_OBJECT_ID);
+}
+
+TEST_F(DisabledRedisClientTest, getAsicViewReturnsEmpty)
+{
+    auto result = m_redisClient->getAsicView();
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getTempAsicViewReturnsEmpty)
+{
+    auto result = m_redisClient->getTempAsicView();
+    EXPECT_TRUE(result.empty());
+}
+
+TEST_F(DisabledRedisClientTest, getSwitchHiddenAttributeReturnsNullptr)
+{
+    sai_object_id_t switchVid = 0x21000000000000;
+    auto result = m_redisClient->getSwitchHiddenAttribute(switchVid, "someAttr");
+    EXPECT_EQ(result, nullptr);
+}
+
+TEST_F(DisabledRedisClientTest, voidMethodsDoNotThrow)
+{
+    sai_object_id_t switchVid = 0x21000000000000;
+    sai_object_id_t vid = 0x21000000000001;
+    sai_object_id_t rid = 0x10000000000001;
+
+    EXPECT_NO_THROW(m_redisClient->clearLaneMap(switchVid));
+
+    std::unordered_map<sai_uint32_t, sai_object_id_t> laneMap;
+    EXPECT_NO_THROW(m_redisClient->saveLaneMap(switchVid, laneMap));
+
+    EXPECT_NO_THROW(m_redisClient->setDummyAsicStateObject(vid));
+
+    sai_object_id_t objectVids[1] = {vid};
+    EXPECT_NO_THROW(m_redisClient->setDummyAsicStateObjects(1, objectVids));
+
+    std::set<sai_object_id_t> coldVids;
+    EXPECT_NO_THROW(m_redisClient->saveColdBootDiscoveredVids(switchVid, coldVids));
+
+    EXPECT_NO_THROW(m_redisClient->saveSwitchHiddenAttribute(switchVid, "attr", rid));
+
+    std::vector<uint32_t> lanes = {1, 2};
+    EXPECT_NO_THROW(m_redisClient->setPortLanes(switchVid, rid, lanes));
+
+    EXPECT_NO_THROW(m_redisClient->removeAsicObject(vid));
+
+    sai_object_meta_key_t metaKey;
+    metaKey.objecttype = SAI_OBJECT_TYPE_SWITCH;
+    metaKey.objectkey.key.object_id = vid;
+    EXPECT_NO_THROW(m_redisClient->removeAsicObject(metaKey));
+
+    EXPECT_NO_THROW(m_redisClient->removeTempAsicObject(metaKey));
+
+    std::vector<swss::FieldValueTuple> attrs;
+    EXPECT_NO_THROW(m_redisClient->createAsicObject(metaKey, attrs));
+
+    EXPECT_NO_THROW(m_redisClient->createTempAsicObject(metaKey, attrs));
+
+    std::unordered_map<std::string, std::vector<swss::FieldValueTuple>> multiHash;
+    EXPECT_NO_THROW(m_redisClient->createAsicObjects(multiHash));
+
+    EXPECT_NO_THROW(m_redisClient->createTempAsicObjects(multiHash));
+
+    std::unordered_map<sai_object_id_t, sai_object_id_t> vidRidMap;
+    EXPECT_NO_THROW(m_redisClient->setVidAndRidMap(vidRidMap));
+
+    EXPECT_NO_THROW(m_redisClient->removeColdVid(vid));
+
+    EXPECT_NO_THROW(m_redisClient->removeVidAndRid(vid, rid));
+
+    EXPECT_NO_THROW(m_redisClient->insertVidAndRid(vid, rid));
+
+    sai_object_id_t vids[1] = {vid};
+    sai_object_id_t rids[1] = {rid};
+    EXPECT_NO_THROW(m_redisClient->insertVidsAndRids(1, vids, rids));
+
+    sai_object_id_t outVids[1];
+    EXPECT_NO_THROW(m_redisClient->getVidsForRids(1, rids, outVids));
+    EXPECT_EQ(outVids[0], SAI_NULL_OBJECT_ID);
+
+    EXPECT_NO_THROW(m_redisClient->removeAsicStateTable());
+
+    EXPECT_NO_THROW(m_redisClient->removeTempAsicStateTable());
+
+    EXPECT_NO_THROW(m_redisClient->setAsicObject(metaKey, "attr", "value"));
+
+    EXPECT_NO_THROW(m_redisClient->setTempAsicObject(metaKey, "attr", "value"));
+
+    std::vector<std::string> keys;
+    EXPECT_NO_THROW(m_redisClient->removeTempAsicObjects(keys));
+
+    EXPECT_NO_THROW(m_redisClient->processFlushEvent(switchVid, vid, vid, SAI_FDB_FLUSH_ENTRY_TYPE_DYNAMIC));
+}
+
diff --git a/unittest/syncd/TestNotificationProcessor.cpp b/unittest/syncd/TestNotificationProcessor.cpp
index 6b75d1f7..b3c2a417 100644
--- a/unittest/syncd/TestNotificationProcessor.cpp
+++ b/unittest/syncd/TestNotificationProcessor.cpp
@@ -1,4 +1,5 @@
 #include "VirtualOidTranslator.h"
+#include "RedisClient.h"
 #include "RedisNotificationProducer.h"
 #include "NotificationProcessor.h"
 #include "lib/RedisVidIndexGenerator.h"
diff --git a/unittest/syncd/TestSyncd.cpp b/unittest/syncd/TestSyncd.cpp
index 49a3c786..0001e31d 100644
--- a/unittest/syncd/TestSyncd.cpp
+++ b/unittest/syncd/TestSyncd.cpp
@@ -1,4 +1,5 @@
 #include "Syncd.h"
+#include "RedisClient.h"
 #include "sai_serialize.h"
 #include "RequestShutdown.h"
 #include "vslib/ContextConfigContainer.h"
@@ -235,7 +236,7 @@ void clearDB()
 class MockSaiSwitch : public SaiSwitch {
 public:
     MockSaiSwitch(sai_object_id_t switchVid, sai_object_id_t switchRid,
-                  std::shared_ptr<RedisClient> client,
+                  std::shared_ptr<BaseRedisClient> client,
                   std::shared_ptr<VirtualOidTranslator> translator,
                   std::shared_ptr<MockableSaiInterface> sai, bool warmBoot)
         : SaiSwitch(switchVid, switchRid, client, translator, sai, warmBoot) {}
diff --git a/unittest/syncd/TestVirtualOidTranslator.cpp b/unittest/syncd/TestVirtualOidTranslator.cpp
index 09d992a3..faf26816 100644
--- a/unittest/syncd/TestVirtualOidTranslator.cpp
+++ b/unittest/syncd/TestVirtualOidTranslator.cpp
@@ -1,4 +1,5 @@
 #include "VirtualOidTranslator.h"
+#include "RedisClient.h"
 #include "VendorSai.h"
 #include "lib/RedisVidIndexGenerator.h"
 #include "lib/sairediscommon.h"