diff --git a/ro_core/core/core.go b/ro_core/core/core.go
index da9fead..a125798 100644
--- a/ro_core/core/core.go
+++ b/ro_core/core/core.go
@@ -18,6 +18,7 @@
 
 import (
 	"context"
+	"fmt"
 
 	"time"
 
@@ -60,7 +61,7 @@
 }
 
 // NewCore instantiates core service parameters
-func NewCore(id string, cf *config.ROCoreFlags, kvClient kvstore.Client) *Core {
+func NewCore(ctx context.Context, id string, cf *config.ROCoreFlags, kvClient kvstore.Client) *Core {
 	var core Core
 	core.instanceID = id
 	core.exitChannel = make(chan int, 1)
@@ -85,8 +86,7 @@
 		PathPrefix:              "service/voltha"}
 	core.clusterDataRoot = model.NewRoot(&voltha.Voltha{}, &core.backend)
 	core.localDataRoot = model.NewRoot(&voltha.CoreInstance{}, &core.backend)
-	core.clusterDataProxy = core.clusterDataRoot.CreateProxy(context.Background(), "/", false)
-	core.localDataProxy = core.localDataRoot.CreateProxy(context.Background(), "/", false)
+
 	return &core
 }
 
@@ -123,7 +123,8 @@
 }
 
 // Start will start core adapter services
-func (core *Core) Start(ctx context.Context) {
+func (core *Core) Start(ctx context.Context) error {
+	var err error
 	log.Info("starting-adaptercore", log.Fields{"coreId": core.instanceID})
 
 	// Wait until connection to KV Store is up
@@ -133,6 +134,16 @@
 
 	probe.UpdateStatusFromContext(ctx, "kv-store", probe.ServiceStatusRunning)
 
+	core.clusterDataProxy, err = core.clusterDataRoot.CreateProxy(context.Background(), "/", false)
+	if err != nil {
+		probe.UpdateStatusFromContext(ctx, "kv-store", probe.ServiceStatusNotReady)
+		return fmt.Errorf("Failed to create cluster data proxy")
+	}
+	core.localDataProxy, err = core.localDataRoot.CreateProxy(context.Background(), "/", false)
+	if err != nil {
+		probe.UpdateStatusFromContext(ctx, "kv-store", probe.ServiceStatusNotReady)
+		return fmt.Errorf("Failed to create local cluster data proxy")
+	}
 	core.genericMgr = newModelProxyManager(core.clusterDataProxy)
 	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 	core.logicalDeviceMgr = newLogicalDeviceManager(core.deviceMgr, core.clusterDataProxy)
@@ -142,6 +153,7 @@
 	go core.monitorKvstoreLiveness(ctx)
 
 	log.Info("adaptercore-started")
+	return nil
 }
 
 // Stop will stop core services
diff --git a/ro_core/core/core_test.go b/ro_core/core/core_test.go
index d88a7de..02cdc84 100644
--- a/ro_core/core/core_test.go
+++ b/ro_core/core/core_test.go
@@ -91,10 +91,12 @@
 
 func TestNewCore(t *testing.T) {
 
+	var ctx context.Context
+
 	roCoreFlgs, roC := makeTestNewCore()
 	assert.NotNil(t, roCoreFlgs)
 	assert.NotNil(t, roC)
-	core := NewCore("ro_core", roCoreFlgs, roC.kvClient)
+	core := NewCore(ctx, "ro_core", roCoreFlgs, roC.kvClient)
 	assert.NotNil(t, core)
 }
 
@@ -105,9 +107,10 @@
 	roCoreFlgs, roC := makeTestNewCore()
 	assert.NotNil(t, roCoreFlgs)
 	assert.NotNil(t, roC)
-	core := NewCore("ro_core", roCoreFlgs, roC.kvClient)
+	core := NewCore(ctx, "ro_core", roCoreFlgs, roC.kvClient)
 	assert.NotNil(t, core)
 
-	core.Start(ctx)
+	err := core.Start(ctx)
+	assert.Nil(t, err)
 	core.Stop(ctx)
 }
diff --git a/ro_core/core/device_agent.go b/ro_core/core/device_agent.go
index 345e424..b056bec 100644
--- a/ro_core/core/device_agent.go
+++ b/ro_core/core/device_agent.go
@@ -59,7 +59,10 @@
 	defer agent.lockDevice.Unlock()
 	log.Debugw("starting-device-agent", log.Fields{"device": agent.lastData})
 	if loadFromDb {
-		if device := agent.clusterDataProxy.Get(ctx, "/devices/"+agent.deviceID, 0, false, ""); device != nil {
+		if device, err := agent.clusterDataProxy.Get(ctx, "/devices/"+agent.deviceID, 0, false, ""); err != nil {
+			log.Errorw("failed-to-get-device", log.Fields{"error": err})
+			return err
+		} else if device != nil {
 			if d, ok := device.(*voltha.Device); ok {
 				agent.lastData = proto.Clone(d).(*voltha.Device)
 			}
@@ -86,7 +89,10 @@
 func (agent *DeviceAgent) getDevice() (*voltha.Device, error) {
 	agent.lockDevice.Lock()
 	defer agent.lockDevice.Unlock()
-	if device := agent.clusterDataProxy.Get(context.Background(), "/devices/"+agent.deviceID, 0, false, ""); device != nil {
+	if device, err := agent.clusterDataProxy.Get(context.Background(), "/devices/"+agent.deviceID, 0, false, ""); err != nil {
+		log.Errorw("failed-to-get-device", log.Fields{"error": err})
+		return nil, err
+	} else if device != nil {
 		if d, ok := device.(*voltha.Device); ok {
 			cloned := proto.Clone(d).(*voltha.Device)
 			return cloned, nil
diff --git a/ro_core/core/device_manager.go b/ro_core/core/device_manager.go
index 634566c..b73ec10 100644
--- a/ro_core/core/device_manager.go
+++ b/ro_core/core/device_manager.go
@@ -132,7 +132,10 @@
 func (dMgr *DeviceManager) ListDevices() (*voltha.Devices, error) {
 	log.Debug("ListDevices")
 	result := &voltha.Devices{}
-	if devices := dMgr.clusterDataProxy.List(context.Background(), "/devices", 0, false, ""); devices != nil {
+	if devices, err := dMgr.clusterDataProxy.List(context.Background(), "/devices", 0, false, ""); err != nil {
+		log.Errorw("failed-to-list-devices", log.Fields{"error": err})
+		return nil, err
+	} else if devices != nil {
 		for _, device := range devices.([]interface{}) {
 			// If device is not in memory then set it up
 			if !dMgr.IsDeviceInCache(device.(*voltha.Device).Id) {
diff --git a/ro_core/core/grpc_nbi_api_handler.go b/ro_core/core/grpc_nbi_api_handler.go
index a611337..0a73ff2 100644
--- a/ro_core/core/grpc_nbi_api_handler.go
+++ b/ro_core/core/grpc_nbi_api_handler.go
@@ -153,7 +153,12 @@
 // ListDevices returns the contents of all devices known to the system
 func (handler *APIHandler) ListDevices(ctx context.Context, empty *empty.Empty) (*voltha.Devices, error) {
 	log.Debug("ListDevices")
-	return handler.deviceMgr.ListDevices()
+	devices, err := handler.deviceMgr.ListDevices()
+	if err != nil {
+		log.Errorw("failed-to-list-devices", log.Fields{"error": err})
+		return nil, err
+	}
+	return devices, nil
 }
 
 // ListDeviceIds returns the list of device ids managed by a voltha core
diff --git a/ro_core/core/grpc_nbi_api_handler_test.go b/ro_core/core/grpc_nbi_api_handler_test.go
index 3244fd3..0a95daa 100644
--- a/ro_core/core/grpc_nbi_api_handler_test.go
+++ b/ro_core/core/grpc_nbi_api_handler_test.go
@@ -29,6 +29,7 @@
 )
 
 func MakeTestGrpcNbiConfig() *Core {
+	var ctx context.Context
 	var core *Core
 	var roCoreFlgs *config.ROCoreFlags
 	var roC *roCore
@@ -44,7 +45,7 @@
 			cli, err := newKVClient("etcd", addr, 5)
 			if err == nil {
 				roC.kvClient = cli
-				core = NewCore("ro_core", roCoreFlgs, roC.kvClient)
+				core = NewCore(ctx, "ro_core", roCoreFlgs, roC.kvClient)
 			}
 		}
 	}
diff --git a/ro_core/core/logical_device_agent.go b/ro_core/core/logical_device_agent.go
index 829aa6b..407511f 100644
--- a/ro_core/core/logical_device_agent.go
+++ b/ro_core/core/logical_device_agent.go
@@ -60,7 +60,10 @@
 	if loadFromDb {
 		//	load from dB - the logical may not exist at this time.  On error, just return and the calling function
 		// will destroy this agent.
-		if logicalDevice := agent.clusterDataProxy.Get(ctx, "/logical_devices/"+agent.logicalDeviceID, 0, false, ""); logicalDevice != nil {
+		if logicalDevice, err := agent.clusterDataProxy.Get(ctx, "/logical_devices/"+agent.logicalDeviceID, 0, false, ""); err != nil {
+			log.Errorw("failed-to-get-logical-device", log.Fields{"error": err})
+			return err
+		} else if logicalDevice != nil {
 			if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
 				agent.lastData = proto.Clone(lDevice).(*voltha.LogicalDevice)
 			}
@@ -88,7 +91,10 @@
 	log.Debug("GetLogicalDevice")
 	agent.lockLogicalDevice.Lock()
 	defer agent.lockLogicalDevice.Unlock()
-	if logicalDevice := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceID, 0, false, ""); logicalDevice != nil {
+	if logicalDevice, err := agent.clusterDataProxy.Get(context.Background(), "/logical_devices/"+agent.logicalDeviceID, 0, false, ""); err != nil {
+		log.Errorw("failed-to-get-logical-device", log.Fields{"error": err})
+		return nil, err
+	} else if logicalDevice != nil {
 		if lDevice, ok := logicalDevice.(*voltha.LogicalDevice); ok {
 			return lDevice, nil
 		}
diff --git a/ro_core/core/logical_device_agent_test.go b/ro_core/core/logical_device_agent_test.go
index 09de443..1685606 100644
--- a/ro_core/core/logical_device_agent_test.go
+++ b/ro_core/core/logical_device_agent_test.go
@@ -16,7 +16,9 @@
 package core
 
 import (
+	"context"
 	"github.com/opencord/voltha-go/ro_core/config"
+	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/phayes/freeport"
 	"github.com/stretchr/testify/assert"
 	"strconv"
@@ -24,6 +26,7 @@
 )
 
 func MakeTestLogDevAgConfig() (*Core, error) {
+	var ctx context.Context
 	var core *Core
 	var roCoreFlgs *config.ROCoreFlags
 	var roC *roCore
@@ -34,6 +37,7 @@
 
 		roCoreFlgs = config.NewROCoreFlags()
 		roC = newROCore(roCoreFlgs)
+
 		if (roC != nil) && (roCoreFlgs != nil) {
 			addr := "127.0.0.1" + ":" + freePortStr
 			cli, err := newKVClient("etcd", addr, 5)
@@ -44,8 +48,7 @@
 		}
 	}
 
-	core = NewCore("ro_core", roCoreFlgs, roC.kvClient)
-
+	core = NewCore(ctx, "ro_core", roCoreFlgs, roC.kvClient)
 	return core, nil
 }
 
@@ -62,6 +65,12 @@
 	core, _ := MakeTestLogDevAgConfig()
 	assert.NotNil(t, core)
 
+	var err1 error
+	if core.clusterDataProxy, err1 = core.localDataRoot.CreateProxy(context.Background(), "/", false); err1 != nil {
+		log.Errorw("failed-to-create-cluster-proxy", log.Fields{"error": err1})
+		assert.NotNil(t, err1)
+	}
+
 	logDevMgr := newLogicalDeviceManager(core.deviceMgr, core.clusterDataProxy)
 	assert.NotNil(t, logDevMgr)
 
diff --git a/ro_core/core/logical_device_manager.go b/ro_core/core/logical_device_manager.go
index 97bc603..fc09f12 100644
--- a/ro_core/core/logical_device_manager.go
+++ b/ro_core/core/logical_device_manager.go
@@ -103,7 +103,11 @@
 func (ldMgr *LogicalDeviceManager) listLogicalDevices() (*voltha.LogicalDevices, error) {
 	log.Debug("ListAllLogicalDevices")
 	result := &voltha.LogicalDevices{}
-	if logicalDevices := ldMgr.clusterDataProxy.List(context.Background(), "/logical_devices", 0, false, ""); logicalDevices != nil {
+	if logicalDevices, err := ldMgr.clusterDataProxy.List(context.Background(), "/logical_devices", 0, false,
+		""); err != nil {
+		log.Errorw("failed-to-list-devices", log.Fields{"error": err})
+		return nil, err
+	} else if logicalDevices != nil {
 		for _, logicalDevice := range logicalDevices.([]interface{}) {
 			result.Items = append(result.Items, logicalDevice.(*voltha.LogicalDevice))
 		}
diff --git a/ro_core/core/logical_device_manager_test.go b/ro_core/core/logical_device_manager_test.go
index e7b33bc..a53e4ec 100644
--- a/ro_core/core/logical_device_manager_test.go
+++ b/ro_core/core/logical_device_manager_test.go
@@ -22,6 +22,7 @@
 
 	"github.com/opencord/voltha-go/db/model"
 	"github.com/opencord/voltha-go/ro_core/config"
+	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/opencord/voltha-protos/v2/go/openflow_13"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"github.com/stretchr/testify/assert"
@@ -30,9 +31,13 @@
 func MakeTestNewCoreConfig() *Core {
 	var core Core
 	core.instanceID = "ro_core"
+	var err error
 	core.config = config.NewROCoreFlags()
 	core.clusterDataRoot = model.NewRoot(&voltha.Voltha{}, nil)
-	core.clusterDataProxy = core.clusterDataRoot.CreateProxy(context.Background(), "/", false)
+	core.clusterDataProxy, err = core.clusterDataRoot.CreateProxy(context.Background(), "/", false)
+	if err != nil {
+		log.With(log.Fields{"error": err}).Fatal("Cannot create cluster data proxy")
+	}
 	core.genericMgr = newModelProxyManager(core.clusterDataProxy)
 	core.deviceMgr = newDeviceManager(core.clusterDataProxy, core.instanceID)
 
@@ -127,13 +132,18 @@
 
 	/*** Case: getLogicalDevice() is Success ***/
 	// Add Data
-	if added := core.clusterDataProxy.Add(
+	added, err := core.clusterDataProxy.Add(
 		context.Background(),
 		"/logical_devices",
 		&voltha.LogicalDevice{
 			Id: "id",
 		},
-		""); added == nil {
+		"")
+	if err != nil {
+		log.Errorw("failed-to-add-logical-device", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add logical device")
 	}
 	ldAgent := newLogicalDeviceAgent("id", "device_id", ldMgr, core.deviceMgr, core.clusterDataProxy)
@@ -219,7 +229,7 @@
 	device := &voltha.Device{Id: "id", Root: true, ParentId: "parent_id"}
 
 	// Add Data
-	if added := core.clusterDataProxy.Add(
+	added, err := core.clusterDataProxy.Add(
 		context.Background(),
 		"/logical_devices",
 		&voltha.LogicalDevice{
@@ -231,7 +241,12 @@
 				},
 			},
 		},
-		""); added == nil {
+		"")
+	if err != nil {
+		log.Errorw("failed-to-add-logical-device", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add logical device")
 	}
 	ldAgent := newLogicalDeviceAgent("parent_id", "device_id", ldMgr, core.deviceMgr, core.clusterDataProxy)
@@ -273,7 +288,7 @@
 	}
 
 	// Add Data
-	if added := core.clusterDataProxy.Add(
+	added, err := core.clusterDataProxy.Add(
 		context.Background(),
 		"/logical_devices",
 		&voltha.LogicalDevice{
@@ -284,7 +299,12 @@
 				},
 			},
 		},
-		""); added == nil {
+		"")
+	if err != nil {
+		log.Errorw("failed-to-add-logical-device", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add logical device")
 	}
 	ldAgent := newLogicalDeviceAgent("id", "", ldMgr, core.deviceMgr, core.clusterDataProxy)
@@ -319,7 +339,7 @@
 	wantResult := &voltha.Flows{}
 
 	// Add Data
-	if added := core.clusterDataProxy.Add(
+	added, err := core.clusterDataProxy.Add(
 		context.Background(),
 		"/logical_devices",
 		&voltha.LogicalDevice{
@@ -332,7 +352,12 @@
 				},
 			},
 		},
-		""); added == nil {
+		"")
+	if err != nil {
+		log.Errorw("failed-to-add-logical-device", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add logical device")
 	}
 	ldAgent := newLogicalDeviceAgent("id", "", ldMgr, core.deviceMgr, core.clusterDataProxy)
@@ -367,7 +392,7 @@
 	wantResult := &voltha.FlowGroups{}
 
 	// Add Data
-	if added := core.clusterDataProxy.Add(
+	added, err := core.clusterDataProxy.Add(
 		context.Background(),
 		"/logical_devices",
 		&voltha.LogicalDevice{
@@ -382,7 +407,12 @@
 				},
 			},
 		},
-		""); added == nil {
+		"")
+	if err != nil {
+		log.Errorw("failed-to-add-logical-device", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add logical device")
 	}
 	ldAgent := newLogicalDeviceAgent("id", "", ldMgr, core.deviceMgr, core.clusterDataProxy)
@@ -417,7 +447,7 @@
 	wantResult := &voltha.LogicalPort{Id: "123"}
 
 	// Add Data
-	if added := core.clusterDataProxy.Add(
+	added, err := core.clusterDataProxy.Add(
 		context.Background(),
 		"/logical_devices",
 		&voltha.LogicalDevice{
@@ -428,7 +458,12 @@
 				},
 			},
 		},
-		""); added == nil {
+		"")
+	if err != nil {
+		log.Errorw("failed-to-add-logical-device", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add logical device")
 	}
 	ldAgent := newLogicalDeviceAgent("id", "", ldMgr, core.deviceMgr, core.clusterDataProxy)
diff --git a/ro_core/core/model_proxy.go b/ro_core/core/model_proxy.go
index eb93e44..56233eb 100644
--- a/ro_core/core/model_proxy.go
+++ b/ro_core/core/model_proxy.go
@@ -58,7 +58,10 @@
 
 	log.Debugw("get-data", log.Fields{"path": path})
 
-	if data := mp.rootProxy.Get(context.Background(), path, 1, false, ""); data != nil {
+	if data, err := mp.rootProxy.Get(context.Background(), path, 1, false, ""); err != nil {
+		log.Errorw("failed-to-retrieve-data-from-model-proxy", log.Fields{"error": err})
+		return nil, err
+	} else if data != nil {
 		return data, nil
 	}
 	return nil, status.Errorf(codes.NotFound, "data-path: %s", path)
diff --git a/ro_core/core/model_proxy_manager_test.go b/ro_core/core/model_proxy_manager_test.go
index 10411bf..c375f7d 100644
--- a/ro_core/core/model_proxy_manager_test.go
+++ b/ro_core/core/model_proxy_manager_test.go
@@ -18,6 +18,7 @@
 import (
 	"context"
 	"github.com/opencord/voltha-go/db/model"
+	"github.com/opencord/voltha-lib-go/v2/pkg/log"
 	"github.com/opencord/voltha-protos/v2/go/voltha"
 	"github.com/stretchr/testify/assert"
 	"reflect"
@@ -26,7 +27,10 @@
 
 func makeModelProxyManagerObj() *ModelProxyManager {
 	cdRoot := model.NewRoot(&voltha.Voltha{}, nil)
-	cdProxy := cdRoot.CreateProxy(context.Background(), "/", false)
+	cdProxy, err := cdRoot.CreateProxy(context.Background(), "/", false)
+	if err != nil {
+		log.With(log.Fields{"error": err}).Fatal("Failed to create model proxy manager")
+	}
 	mpMgr := newModelProxyManager(cdProxy)
 	return mpMgr
 }
@@ -103,7 +107,12 @@
 	assert.Nil(t, err0)
 
 	// Case 2: Found
-	if added := mpMgr.clusterDataProxy.Add(context.Background(), "/adapters", &voltha.Adapter{Id: "id"}, ""); added == nil {
+	added, err := mpMgr.clusterDataProxy.Add(context.Background(), "/adapters", &voltha.Adapter{Id: "id"}, "")
+	if err != nil {
+		log.Errorw("failed-to-add-adapter-to-cluster-proxy", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add adapter")
 	}
 	result1, err1 := mpMgr.ListAdapters(context.Background())
@@ -135,7 +144,12 @@
 	assert.Nil(t, err0)
 
 	// Case 2: Found
-	if added := mpMgr.clusterDataProxy.Add(context.Background(), "/device_types", &voltha.DeviceType{Id: "id"}, ""); added == nil {
+	added, err := mpMgr.clusterDataProxy.Add(context.Background(), "/device_types", &voltha.DeviceType{Id: "id"}, "")
+	if err != nil {
+		log.Errorw("failed-to-add-device-types-to-cluster-proxy", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add device type")
 	}
 	result1, err1 := mpMgr.ListDeviceTypes(context.Background())
@@ -160,7 +174,11 @@
 	assert.NotNil(t, err0)
 
 	// Case 2: Found
-	if added := mpMgr.clusterDataProxy.Add(context.Background(), "/device_types", &voltha.DeviceType{Id: "id"}, ""); added == nil {
+	added, err := mpMgr.clusterDataProxy.Add(context.Background(), "/device_types", &voltha.DeviceType{Id: "id"}, "")
+	if err != nil {
+		log.Errorw("failed-to-add-adapter-to-device-types-proxy", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	} else if added == nil {
 		t.Error("Failed to add device type")
 	}
 	result1, err1 := mpMgr.GetDeviceType(context.Background(), "id")
@@ -192,7 +210,12 @@
 	assert.Nil(t, err0)
 
 	// Case 2: Found
-	if added := mpMgr.clusterDataProxy.Add(context.Background(), "/device_groups", &voltha.DeviceGroup{Id: "id"}, ""); added == nil {
+	added, err := mpMgr.clusterDataProxy.Add(context.Background(), "/device_groups", &voltha.DeviceGroup{Id: "id"}, "")
+	if err != nil {
+		log.Errorw("failed-to-add-device-groups-to-cluster-proxy", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add device group")
 	}
 	result1, err1 := mpMgr.ListDeviceGroups(context.Background())
@@ -217,7 +240,12 @@
 	assert.NotNil(t, err0)
 
 	// Case 2: Found
-	if added := mpMgr.clusterDataProxy.Add(context.Background(), "/device_groups", &voltha.DeviceGroup{Id: "id"}, ""); added == nil {
+	added, err := mpMgr.clusterDataProxy.Add(context.Background(), "/device_groups", &voltha.DeviceGroup{Id: "id"}, "")
+	if err != nil {
+		log.Errorw("failed-to-add-device-groups-to-cluster-proxy", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add device group")
 	}
 	result1, err1 := mpMgr.GetDeviceGroup(context.Background(), "id")
@@ -249,7 +277,12 @@
 	assert.Nil(t, err0)
 
 	// Case 2: Found
-	if added := mpMgr.clusterDataProxy.Add(context.Background(), "/event_filters", &voltha.EventFilter{Id: "id"}, ""); added == nil {
+	added, err := mpMgr.clusterDataProxy.Add(context.Background(), "/event_filters", &voltha.EventFilter{Id: "id"}, "")
+	if err != nil {
+		log.Errorw("failed-to-add-alarm-filters-to-cluster-proxy", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add event filter")
 	}
 	result1, err1 := mpMgr.ListEventFilters(context.Background())
@@ -279,7 +312,13 @@
 	}
 	assert.Nil(t, result0)
 	// Case 2: Found
-	if added := mpMgr.clusterDataProxy.Add(context.Background(), "/event_filters", &voltha.EventFilter{Id: "id"}, ""); added == nil {
+	//added, err := mpMgr.clusterDataProxy.Add(context.Background(), "/alarm_filters", &voltha.EventFilter{Id: "id"}, "")
+	added, err := mpMgr.clusterDataProxy.Add(context.Background(), "/event_filters", &voltha.EventFilter{Id: "id"}, "")
+	if err != nil {
+		log.Errorw("failed-to-add-adapter-to-alarm-filter-to-proxy", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
+	if added == nil {
 		t.Error("Failed to add event filter")
 	}
 	result1, err1 := mpMgr.ListEventFilters(context.Background())
diff --git a/ro_core/core/model_proxy_test.go b/ro_core/core/model_proxy_test.go
index a9caa00..5c26563 100644
--- a/ro_core/core/model_proxy_test.go
+++ b/ro_core/core/model_proxy_test.go
@@ -17,6 +17,8 @@
 
 import (
 	"context"
+	"github.com/opencord/voltha-lib-go/v2/pkg/log"
+	"github.com/stretchr/testify/assert"
 	"reflect"
 	"testing"
 
@@ -31,22 +33,30 @@
 	basePath  string
 }
 
-func getModelProxyPathNotFound() *fields {
+func getModelProxyPathNotFound(t *testing.T) *fields {
 	var modelProxy fields
 
 	TestProxyRoot := model.NewRoot(&voltha.Voltha{}, nil)
-	TestProxyRootProxy := TestProxyRoot.CreateProxy(context.Background(), "/", false)
+	TestProxyRootProxy, err := TestProxyRoot.CreateProxy(context.Background(), "/", false)
+	if err != nil {
+		log.Errorw("failed-to-create-test-proxy", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
 	modelProxy.rootProxy = TestProxyRootProxy
 	modelProxy.basePath = "base_path"
 
 	return &modelProxy
 }
 
-func getModelProxyPathFound() *fields {
+func getModelProxyPathFound(t *testing.T) *fields {
 	var modelProxy fields
 
 	TestProxyRoot := model.NewRoot(&voltha.Voltha{}, nil)
-	TestProxyRootProxy := TestProxyRoot.CreateProxy(context.Background(), "/", false)
+	TestProxyRootProxy, err := TestProxyRoot.CreateProxy(context.Background(), "/", false)
+	if err != nil {
+		log.Errorw("failed-to-create-test-proxy", log.Fields{"error": err})
+		assert.NotNil(t, err)
+	}
 	modelProxy.rootProxy = TestProxyRootProxy
 	modelProxy.basePath = "devices"
 
@@ -88,8 +98,8 @@
 		fields  *fields
 		wantErr error
 	}{
-		{"Get-PathNotFound", getModelProxyPathNotFound(), status.Errorf(codes.NotFound, "data-path: base_path")},
-		{"Get-PathFound", getModelProxyPathFound(), nil},
+		{"Get-PathNotFound", getModelProxyPathNotFound(t), status.Errorf(codes.NotFound, "data-path: base_path")},
+		{"Get-PathFound", getModelProxyPathFound(t), nil},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/ro_core/main.go b/ro_core/main.go
index dc78302..b203bec 100644
--- a/ro_core/main.go
+++ b/ro_core/main.go
@@ -111,14 +111,16 @@
 	}
 
 	// Create the core service
-	ro.core = c.NewCore(ro.config.InstanceID, ro.config, ro.kvClient)
+	ro.core = c.NewCore(ctx, ro.config.InstanceID, ro.config, ro.kvClient)
 
 	if p != nil {
 		p.UpdateStatus("kv-store", probe.ServiceStatusPrepared)
 	}
 
 	// start the core
-	ro.core.Start(ctx)
+	if err := ro.core.Start(ctx); err != nil {
+		log.Fatalf("failed-to-start-rocore", log.Fields{"error": err})
+	}
 }
 
 func (ro *roCore) stop(ctx context.Context) {