diff --git a/applications/venv-manager/venv-manager/venv-manager.go b/applications/venv-manager/venv-manager/venv-manager.go
index 535a47adbe1a18b9330cd1c9877b7ac1c02e2770..64a283c9669464a8977f8130314d3e998daeefb7 100644
--- a/applications/venv-manager/venv-manager/venv-manager.go
+++ b/applications/venv-manager/venv-manager/venv-manager.go
@@ -194,7 +194,7 @@ func (v *VenvManager) loadNetworkElementModelPathsIntoGosdn(ctx context.Context,
 	pndService := pndPb.NewPndServiceClient(conn)
 
 	for _, node := range *nodes {
-		_, err := pndService.GetPath(ctx, &pndPb.GetPathRequest{Did: node.ID, Pid: v.pnd, Path: "lldp"})
+		_, err := pndService.GetPath(ctx, &pndPb.GetPathRequest{Mneid: node.ID, Pid: v.pnd, Path: "lldp"})
 		if err != nil {
 			return err
 		}
diff --git a/controller/api/api_test.go b/controller/api/api_test.go
index 42e98d52d508d9215377c23ff84d6e4d044087a5..02a55df4be5e10f45213f6773d5de4ce3f90cede 100644
--- a/controller/api/api_test.go
+++ b/controller/api/api_test.go
@@ -33,7 +33,7 @@ func Test_GetIds(t *testing.T) {
 
 func ensureFilesForTestsAreRemoved() {
 	ensureStoreFileForTestsIsRemoved(store.SbiFilenameSuffix)
-	ensureStoreFileForTestsIsRemoved(store.DeviceFilenameSuffix)
+	ensureStoreFileForTestsIsRemoved(store.NetworkElementFilenameSuffix)
 }
 
 func ensureStoreFileForTestsIsRemoved(storeName string) {
diff --git a/controller/api/change.go b/controller/api/change.go
index 856ce89c2d320ae98a5deffb33a277dfe08536be..570b0af3374e5ab402a7f17e8765c98997068a66 100644
--- a/controller/api/change.go
+++ b/controller/api/change.go
@@ -84,9 +84,9 @@ func CommitConfirm(ctx context.Context, addr, pnd string, changes []*ppb.SetChan
 // specified in
 // https://github.com/openconfig/reference/blob/master/rpc/gnmi/gnmi-specification.md#34-modifying-state)
 // For delete operations the value field needs to contain an empty string.
-func ChangeRequest(ctx context.Context, addr, did, pid, path, value string, op ppb.ApiOperation) (*ppb.SetPathListResponse, error) {
+func ChangeRequest(ctx context.Context, addr, mneid, pid, path, value string, op ppb.ApiOperation) (*ppb.SetPathListResponse, error) {
 	req := &ppb.ChangeRequest{
-		Did:   did,
+		Mneid: mneid,
 		Path:  path,
 		Value: value,
 		ApiOp: op,
diff --git a/controller/api/initialise_test.go b/controller/api/initialise_test.go
index 436151403d1571a2d0d7b0886b2f600ea809954e..1fed5009d856d4e883b5834a5a57791ef25b841b 100644
--- a/controller/api/initialise_test.go
+++ b/controller/api/initialise_test.go
@@ -9,7 +9,6 @@ import (
 	"time"
 
 	cpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/core"
-	"code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement"
 	ppb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/pnd"
 	apb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/rbac"
 	tpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/transport"
@@ -137,11 +136,11 @@ func bootstrapUnitTest() {
 	mockPnd.On("PendingChanges").Return([]uuid.UUID{changeUUID})
 	mockPnd.On("CommittedChanges").Return([]uuid.UUID{changeUUID})
 	mockPnd.On("GetChange", mock.Anything).Return(mockChange, nil)
-	mockPnd.On("AddDevice", mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
-	mockPnd.On("GetDevice", mock.Anything).Return(mockDevice, nil)
+	mockPnd.On("AddNetworkElement", mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
+	mockPnd.On("GetNetworkElement", mock.Anything).Return(mockDevice, nil)
 	mockPnd.On("Commit", mock.Anything).Return(nil)
 	mockPnd.On("Confirm", mock.Anything).Return(nil)
-	mockPnd.On("Devices").Return([]networkelement.NetworkElement{
+	mockPnd.On("NetworkElements").Return([]networkelement.NetworkElement{
 		&nucleus.CommonNetworkElement{
 			UUID:  mneUUID,
 			Model: &openconfig.Device{},
diff --git a/controller/api/device.go b/controller/api/managedNetworkElement.go
similarity index 88%
rename from controller/api/device.go
rename to controller/api/managedNetworkElement.go
index 4456118b4e5faa297780cc2a0e53fc1d912a0950..8ed8f4d62d9d0cf8bc4c8af75bc2eb54d3aaa8f8 100644
--- a/controller/api/device.go
+++ b/controller/api/managedNetworkElement.go
@@ -53,19 +53,19 @@ func AddNetworkElement(ctx context.Context, addr, mneName string, opt *tpb.Trans
 // GetNetworkElement requests one network element belonging to a given
 // PrincipalNetworkDomain from the controller. If no network element identifier
 // is provided, an error is thrown.
-func GetNetworkElement(ctx context.Context, addr, pid string, did string) (*ppb.GetMneResponse, error) {
+func GetNetworkElement(ctx context.Context, addr, pid string, mneid string) (*ppb.GetMneResponse, error) {
 	pndClient, err := nbi.PndClient(addr, dialOptions...)
 	if err != nil {
 		return nil, err
 	}
 
-	if len(did) == 0 {
+	if len(mneid) == 0 {
 		return nil, err
 	}
 
 	req := &ppb.GetMneRequest{
 		Timestamp: time.Now().UnixNano(),
-		Did:       did,
+		Mneid:     mneid,
 		Pid:       pid,
 	}
 
@@ -137,7 +137,7 @@ func GetFlattenedNetworkElements(ctx context.Context, addr, pid string) (*ppb.Ge
 }
 
 // GetPath requests a specific path.
-func GetPath(ctx context.Context, addr, pid, did, path string) (*ppb.GetPathResponse, error) {
+func GetPath(ctx context.Context, addr, pid, mneid, path string) (*ppb.GetPathResponse, error) {
 	pndClient, err := nbi.PndClient(addr, dialOptions...)
 	if err != nil {
 		return nil, err
@@ -145,7 +145,7 @@ func GetPath(ctx context.Context, addr, pid, did, path string) (*ppb.GetPathResp
 
 	req := &ppb.GetPathRequest{
 		Timestamp: time.Now().UnixNano(),
-		Did:       did,
+		Mneid:     mneid,
 		Pid:       pid,
 		Path:      path,
 	}
@@ -154,7 +154,7 @@ func GetPath(ctx context.Context, addr, pid, did, path string) (*ppb.GetPathResp
 }
 
 // SubscribePath subscribes to paths on a network element.
-func SubscribePath(ctx context.Context, addr, pid, did string, slist *ppb.SubscriptionList) (ppb.PndService_SubscribePathClient, error) {
+func SubscribePath(ctx context.Context, addr, pid, mneid string, slist *ppb.SubscriptionList) (ppb.PndService_SubscribePathClient, error) {
 	log.Println("subscribePath called")
 	pndClient, err := nbi.PndClient(addr, dialOptions...)
 	if err != nil {
@@ -163,7 +163,7 @@ func SubscribePath(ctx context.Context, addr, pid, did string, slist *ppb.Subscr
 
 	req := &ppb.SubscribePathRequest{
 		Timestamp: time.Now().UnixNano(),
-		Did:       did,
+		Mneid:     mneid,
 		Pid:       pid,
 		Sublist:   slist,
 	}
@@ -172,7 +172,7 @@ func SubscribePath(ctx context.Context, addr, pid, did string, slist *ppb.Subscr
 }
 
 // DeleteNetworkElement deletes a network element.
-func DeleteNetworkElement(ctx context.Context, addr, pid, did string) (*ppb.DeleteMneResponse, error) {
+func DeleteNetworkElement(ctx context.Context, addr, pid, mneid string) (*ppb.DeleteMneResponse, error) {
 	pndClient, err := nbi.PndClient(addr, dialOptions...)
 	if err != nil {
 		return nil, err
@@ -180,7 +180,7 @@ func DeleteNetworkElement(ctx context.Context, addr, pid, did string) (*ppb.Dele
 
 	req := &ppb.DeleteMneRequest{
 		Timestamp: time.Now().UnixNano(),
-		Did:       did,
+		Mneid:     mneid,
 		Pid:       pid,
 	}
 
diff --git a/controller/mocks/NetworkDomain.go b/controller/mocks/NetworkDomain.go
index cd21d78c221f27c8c040b1130f8c1916261c513d..00b4f366239da660dbfeeed0092f0f15cfa8708a 100644
--- a/controller/mocks/NetworkDomain.go
+++ b/controller/mocks/NetworkDomain.go
@@ -24,8 +24,8 @@ type NetworkDomain struct {
 	mock.Mock
 }
 
-// AddDevice provides a mock function with given fields: name, opts, sid
-func (_m *NetworkDomain) AddDevice(name string, opts *transport.TransportOption, sid uuid.UUID) (uuid.UUID, error) {
+// AddNetworkElement provides a mock function with given fields: name, opts, sid
+func (_m *NetworkDomain) AddNetworkElement(name string, opts *transport.TransportOption, sid uuid.UUID) (uuid.UUID, error) {
 	ret := _m.Called(name, opts, sid)
 
 	var r0 uuid.UUID
@@ -149,24 +149,8 @@ func (_m *NetworkDomain) Destroy() error {
 	return r0
 }
 
-// Devices provides a mock function with given fields:
-func (_m *NetworkDomain) Devices() []networkelement.NetworkElement {
-	ret := _m.Called()
-
-	var r0 []networkelement.NetworkElement
-	if rf, ok := ret.Get(0).(func() []networkelement.NetworkElement); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]networkelement.NetworkElement)
-		}
-	}
-
-	return r0
-}
-
-// FlattenedDevices provides a mock function with given fields:
-func (_m *NetworkDomain) FlattenedDevices() []networkelement.LoadedNetworkElement {
+// FlattenedNetworkElements provides a mock function with given fields:
+func (_m *NetworkDomain) FlattenedNetworkElements() []networkelement.LoadedNetworkElement {
 	ret := _m.Called()
 
 	var r0 []networkelement.LoadedNetworkElement
@@ -218,8 +202,22 @@ func (_m *NetworkDomain) GetDescription() string {
 	return r0
 }
 
-// GetDevice provides a mock function with given fields: identifier
-func (_m *NetworkDomain) GetDevice(identifier string) (networkelement.NetworkElement, error) {
+// GetName provides a mock function with given fields:
+func (_m *NetworkDomain) GetName() string {
+	ret := _m.Called()
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// GetNetworkElement provides a mock function with given fields: identifier
+func (_m *NetworkDomain) GetNetworkElement(identifier string) (networkelement.NetworkElement, error) {
 	ret := _m.Called(identifier)
 
 	var r0 networkelement.NetworkElement
@@ -241,20 +239,6 @@ func (_m *NetworkDomain) GetDevice(identifier string) (networkelement.NetworkEle
 	return r0, r1
 }
 
-// GetName provides a mock function with given fields:
-func (_m *NetworkDomain) GetName() string {
-	ret := _m.Called()
-
-	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	return r0
-}
-
 // GetSBI provides a mock function with given fields: _a0
 func (_m *NetworkDomain) GetSBI(_a0 uuid.UUID) (southbound.SouthboundInterface, error) {
 	ret := _m.Called(_a0)
@@ -317,8 +301,8 @@ func (_m *NetworkDomain) ID() uuid.UUID {
 	return r0
 }
 
-// MarshalDevice provides a mock function with given fields: _a0
-func (_m *NetworkDomain) MarshalDevice(_a0 string) (string, error) {
+// MarshalNetworkElement provides a mock function with given fields: _a0
+func (_m *NetworkDomain) MarshalNetworkElement(_a0 string) (string, error) {
 	ret := _m.Called(_a0)
 
 	var r0 string
@@ -338,6 +322,22 @@ func (_m *NetworkDomain) MarshalDevice(_a0 string) (string, error) {
 	return r0, r1
 }
 
+// NetworkElements provides a mock function with given fields:
+func (_m *NetworkDomain) NetworkElements() []networkelement.NetworkElement {
+	ret := _m.Called()
+
+	var r0 []networkelement.NetworkElement
+	if rf, ok := ret.Get(0).(func() []networkelement.NetworkElement); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]networkelement.NetworkElement)
+		}
+	}
+
+	return r0
+}
+
 // PendingChanges provides a mock function with given fields:
 func (_m *NetworkDomain) PendingChanges() []uuid.UUID {
 	ret := _m.Called()
@@ -354,8 +354,8 @@ func (_m *NetworkDomain) PendingChanges() []uuid.UUID {
 	return r0
 }
 
-// RemoveDevice provides a mock function with given fields: _a0
-func (_m *NetworkDomain) RemoveDevice(_a0 uuid.UUID) error {
+// RemoveNetworkElement provides a mock function with given fields: _a0
+func (_m *NetworkDomain) RemoveNetworkElement(_a0 uuid.UUID) error {
 	ret := _m.Called(_a0)
 
 	var r0 error
@@ -433,8 +433,8 @@ func (_m *NetworkDomain) SubscribePath(_a0 uuid.UUID, _a1 *pnd.SubscriptionList)
 	return r0
 }
 
-// UpdateDevice provides a mock function with given fields: _a0, _a1
-func (_m *NetworkDomain) UpdateDevice(_a0 networkelement.NetworkElement, _a1 string) error {
+// UpdateNetworkElement provides a mock function with given fields: _a0, _a1
+func (_m *NetworkDomain) UpdateNetworkElement(_a0 networkelement.NetworkElement, _a1 string) error {
 	ret := _m.Called(_a0, _a1)
 
 	var r0 error
@@ -447,8 +447,8 @@ func (_m *NetworkDomain) UpdateDevice(_a0 networkelement.NetworkElement, _a1 str
 	return r0
 }
 
-// UpdateDeviceAfterSubscribeResponse provides a mock function with given fields: _a0
-func (_m *NetworkDomain) UpdateDeviceAfterSubscribeResponse(_a0 networkelement.NetworkElement) error {
+// UpdateNetworkElementAfterSubscribeResponse provides a mock function with given fields: _a0
+func (_m *NetworkDomain) UpdateNetworkElementAfterSubscribeResponse(_a0 networkelement.NetworkElement) error {
 	ret := _m.Called(_a0)
 
 	var r0 error
diff --git a/controller/northbound/server/core_test.go b/controller/northbound/server/core_test.go
index ca949afc288f05a4f40a6968bd850455e010ba87..1b84b875fb2703ad07b31cee61046877db947819 100644
--- a/controller/northbound/server/core_test.go
+++ b/controller/northbound/server/core_test.go
@@ -38,12 +38,12 @@ func getTestCoreServer(t *testing.T) *CoreServer {
 		t.Fatal(err)
 	}
 
-	deviceUUID, err = uuid.Parse(mneID)
+	mneUUID, err = uuid.Parse(mneID)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	mockDevice = &nucleus.CommonNetworkElement{
+	mockNetworkElement = &nucleus.CommonNetworkElement{
 		Model: &openconfig.Device{
 			System: &openconfig.OpenconfigSystem_System{
 				Config: &openconfig.OpenconfigSystem_System_Config{
@@ -52,18 +52,18 @@ func getTestCoreServer(t *testing.T) *CoreServer {
 				},
 			},
 		},
-		UUID: deviceUUID,
+		UUID: mneUUID,
 	}
 
 	sbi, err := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG, sbiUUID)
 	if err != nil {
 		t.Fatal(err)
 	}
-	mockDevice.(*nucleus.CommonDevice).SetSBI(sbi)
-	mockDevice.(*nucleus.CommonDevice).SetTransport(&mocks.Transport{})
-	mockDevice.(*nucleus.CommonDevice).SetName(hostname)
+	mockNetworkElement.(*nucleus.CommonNetworkElement).SetSBI(sbi)
+	mockNetworkElement.(*nucleus.CommonNetworkElement).SetTransport(&mocks.Transport{})
+	mockNetworkElement.(*nucleus.CommonNetworkElement).SetName(hostname)
 	sbiStore = nucleus.NewSbiStore(pndUUID)
-	if err := sbiStore.Add(mockDevice.SBI()); err != nil {
+	if err := sbiStore.Add(mockNetworkElement.SBI()); err != nil {
 		t.Fatal(err)
 	}
 
@@ -76,13 +76,13 @@ func getTestCoreServer(t *testing.T) *CoreServer {
 	mockPnd.On("GetName").Return("test")
 	mockPnd.On("GetDescription").Return("test")
 	mockPnd.On("GetSBIs").Return(sbiStore)
-	mockPnd.On("GetSBI", mock.Anything).Return(mockDevice.SBI(), nil)
-	mockPnd.On("Devices").Return([]uuid.UUID{deviceUUID})
+	mockPnd.On("GetSBI", mock.Anything).Return(mockNetworkElement.SBI(), nil)
+	mockPnd.On("Devices").Return([]uuid.UUID{mneUUID})
 	mockPnd.On("PendingChanges").Return([]uuid.UUID{pendingChangeUUID})
 	mockPnd.On("CommittedChanges").Return([]uuid.UUID{committedChangeUUID})
 	mockPnd.On("GetChange", mock.Anything).Return(mockChange, nil)
-	mockPnd.On("AddDevice", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-	mockPnd.On("GetDevice", mock.Anything).Return(mockDevice, nil)
+	mockPnd.On("AddNetworkElement", mock.Anything, mock.Anything, mock.Anything).Return(nil)
+	mockPnd.On("GetNetworkElement", mock.Anything).Return(mockNetworkElement, nil)
 	mockPnd.On("Commit", mock.Anything).Return(nil)
 	mockPnd.On("Confirm", mock.Anything).Return(nil)
 	mockPnd.On("ChangeMNE", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(uuid.Nil, nil)
diff --git a/controller/northbound/server/pnd_test.go b/controller/northbound/server/pnd_test.go
index 90a878f1d4f301809a2875ddf8b34fd8fde3dd17..f5f15f0cb857a29d84d08288c58a763bff0617d2 100644
--- a/controller/northbound/server/pnd_test.go
+++ b/controller/northbound/server/pnd_test.go
@@ -40,12 +40,12 @@ func getTestPndServer(t *testing.T) *PndServer {
 		t.Fatal(err)
 	}
 
-	deviceUUID, err = uuid.Parse(mneID)
+	mneUUID, err = uuid.Parse(mneID)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	mockDevice = &nucleus.CommonNetworkElement{
+	mockNetworkElement = &nucleus.CommonNetworkElement{
 		Model: &openconfig.Device{
 			System: &openconfig.OpenconfigSystem_System{
 				Config: &openconfig.OpenconfigSystem_System_Config{
@@ -54,18 +54,18 @@ func getTestPndServer(t *testing.T) *PndServer {
 				},
 			},
 		},
-		UUID: deviceUUID,
+		UUID: mneUUID,
 	}
 
 	sbi, err := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG, sbiUUID)
 	if err != nil {
 		t.Fatal(err)
 	}
-	mockDevice.(*nucleus.CommonDevice).SetSBI(sbi)
-	mockDevice.(*nucleus.CommonDevice).SetTransport(&mocks.Transport{})
-	mockDevice.(*nucleus.CommonDevice).SetName(hostname)
+	mockNetworkElement.(*nucleus.CommonNetworkElement).SetSBI(sbi)
+	mockNetworkElement.(*nucleus.CommonNetworkElement).SetTransport(&mocks.Transport{})
+	mockNetworkElement.(*nucleus.CommonNetworkElement).SetName(hostname)
 	sbiStore = nucleus.NewSbiStore(pndUUID)
-	if err := sbiStore.Add(mockDevice.SBI()); err != nil {
+	if err := sbiStore.Add(mockNetworkElement.SBI()); err != nil {
 		t.Fatal(err)
 	}
 
@@ -78,13 +78,13 @@ func getTestPndServer(t *testing.T) *PndServer {
 	mockPnd.On("GetName").Return("test")
 	mockPnd.On("GetDescription").Return("test")
 	mockPnd.On("GetSBIs").Return(sbiStore)
-	mockPnd.On("GetSBI", mock.Anything).Return(mockDevice.SBI(), nil)
-	mockPnd.On("Devices").Return([]uuid.UUID{deviceUUID})
+	mockPnd.On("GetSBI", mock.Anything).Return(mockNetworkElement.SBI(), nil)
+	mockPnd.On("NetworkElements").Return([]uuid.UUID{mneUUID})
 	mockPnd.On("PendingChanges").Return([]uuid.UUID{pendingChangeUUID})
 	mockPnd.On("CommittedChanges").Return([]uuid.UUID{committedChangeUUID})
 	mockPnd.On("GetChange", mock.Anything).Return(mockChange, nil)
-	mockPnd.On("AddDevice", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-	mockPnd.On("GetDevice", mock.Anything).Return(mockDevice, nil)
+	mockPnd.On("AddNetworkElement", mock.Anything, mock.Anything, mock.Anything).Return(nil)
+	mockPnd.On("GetNetworkElement", mock.Anything).Return(mockNetworkElement, nil)
 	mockPnd.On("Commit", mock.Anything).Return(nil)
 	mockPnd.On("Confirm", mock.Anything).Return(nil)
 	mockPnd.On("ChangeMNE", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(uuid.Nil, nil)
@@ -128,7 +128,7 @@ func Test_pnd_GetPath(t *testing.T) {
 				ctx: context.Background(),
 				request: &ppb.GetPathRequest{
 					Timestamp: time.Now().UnixNano(),
-					Did:       deviceUUID.String(),
+					Mneid:     mneUUID.String(),
 					Path:      "system/config/hostname",
 					Pid:       pndUUID.String(),
 				},
@@ -166,7 +166,7 @@ func Test_pnd_GetPath(t *testing.T) {
 				ctx: context.Background(),
 				request: &ppb.GetPathRequest{
 					Timestamp: time.Now().UnixNano(),
-					Did:       deviceUUID.String(),
+					Mneid:     mneUUID.String(),
 					Path:      "system",
 					Pid:       pndUUID.String(),
 				},
@@ -198,7 +198,7 @@ func Test_pnd_GetPath(t *testing.T) {
 				ctx: context.Background(),
 				request: &ppb.GetPathRequest{
 					Timestamp: time.Now().UnixNano(),
-					Did:       deviceUUID.String(),
+					Mneid:     mneUUID.String(),
 					Path:      "this/path/is/not/valid",
 					Pid:       pndUUID.String(),
 				},
@@ -216,7 +216,7 @@ func Test_pnd_GetPath(t *testing.T) {
 				return
 			}
 
-			got := resp.GetDevice()
+			got := resp.GetMneNotification()
 
 			for i, n := range got {
 				if diff := cmp.Diff(n.GetUpdate(), tt.want[i].GetUpdate(), opts...); diff != "" {
diff --git a/controller/northbound/server/test_util_test.go b/controller/northbound/server/test_util_test.go
index 21037ae482255dbc0203f508a2d49f59ce81e03d..4a4202e0470fea150b8ad3aa74f3cb28f022c2ea 100644
--- a/controller/northbound/server/test_util_test.go
+++ b/controller/northbound/server/test_util_test.go
@@ -7,8 +7,8 @@ import (
 	"testing"
 
 	spb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/southbound"
-	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/device"
 	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkdomain"
+	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkelement"
 	rbacInterfaces "code.fbi.h-da.de/danet/gosdn/controller/interfaces/rbac"
 	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/southbound"
 	"code.fbi.h-da.de/danet/gosdn/controller/mocks"
@@ -35,9 +35,9 @@ var pndUUID uuid.UUID
 var sbiUUID uuid.UUID
 var pendingChangeUUID uuid.UUID
 var committedChangeUUID uuid.UUID
-var deviceUUID uuid.UUID
+var mneUUID uuid.UUID
 var mockPnd *mocks.NetworkDomain
-var mockDevice device.Device
+var mockNetworkElement networkelement.NetworkElement
 var sbiStore southbound.Store
 
 // Name of this file requires _test at the end, because of how the availability of varibales is handled in test files of go packages.
@@ -206,7 +206,7 @@ func createHashedAndSaltedPassword(plainPWD, salt string) string {
 }
 
 func getMockPnd(t *testing.T) networkdomain.NetworkDomain {
-	mockDevice = &nucleus.CommonNetworkElement{
+	mockNetworkElement = &nucleus.CommonNetworkElement{
 		Model: &openconfig.Device{
 			System: &openconfig.OpenconfigSystem_System{
 				Config: &openconfig.OpenconfigSystem_System_Config{
@@ -215,18 +215,18 @@ func getMockPnd(t *testing.T) networkdomain.NetworkDomain {
 				},
 			},
 		},
-		UUID: deviceUUID,
+		UUID: mneUUID,
 	}
 
 	sbi, err := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG, sbiUUID)
 	if err != nil {
 		t.Fatal(err)
 	}
-	mockDevice.(*nucleus.CommonDevice).SetSBI(sbi)
-	mockDevice.(*nucleus.CommonDevice).SetTransport(&mocks.Transport{})
-	mockDevice.(*nucleus.CommonDevice).SetName(hostname)
+	mockNetworkElement.(*nucleus.CommonNetworkElement).SetSBI(sbi)
+	mockNetworkElement.(*nucleus.CommonNetworkElement).SetTransport(&mocks.Transport{})
+	mockNetworkElement.(*nucleus.CommonNetworkElement).SetName(hostname)
 	sbiStore = nucleus.NewSbiStore(pndUUID)
-	if err := sbiStore.Add(mockDevice.SBI()); err != nil {
+	if err := sbiStore.Add(mockNetworkElement.SBI()); err != nil {
 		t.Fatal(err)
 	}
 
@@ -235,12 +235,12 @@ func getMockPnd(t *testing.T) networkdomain.NetworkDomain {
 	mockPnd.On("GetName").Return("test")
 	mockPnd.On("GetDescription").Return("test")
 	mockPnd.On("GetSBIs").Return(sbiStore)
-	mockPnd.On("GetSBI", mock.Anything).Return(mockDevice.SBI(), nil)
-	mockPnd.On("Devices").Return([]uuid.UUID{deviceUUID})
+	mockPnd.On("GetSBI", mock.Anything).Return(mockNetworkElement.SBI(), nil)
+	mockPnd.On("NetworkElements").Return([]uuid.UUID{mneUUID})
 	mockPnd.On("PendingChanges").Return([]uuid.UUID{pendingChangeUUID})
 	mockPnd.On("CommittedChanges").Return([]uuid.UUID{committedChangeUUID})
-	mockPnd.On("AddDevice", mock.Anything, mock.Anything, mock.Anything).Return(nil)
-	mockPnd.On("GetDevice", mock.Anything).Return(mockDevice, nil)
+	mockPnd.On("AddNetworkElement", mock.Anything, mock.Anything, mock.Anything).Return(nil)
+	mockPnd.On("GetNetworkElement", mock.Anything).Return(mockNetworkElement, nil)
 	mockPnd.On("Commit", mock.Anything).Return(nil)
 	mockPnd.On("Confirm", mock.Anything).Return(nil)
 	mockPnd.On("ChangeMNE", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(uuid.Nil, nil)
@@ -271,7 +271,7 @@ func initUUIDs(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	deviceUUID, err = uuid.Parse(mneID)
+	mneUUID, err = uuid.Parse(mneID)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/controller/nucleus/deviceFilesystemStore.go b/controller/nucleus/deviceFilesystemStore.go
deleted file mode 100644
index 61561f83dc5b52ce2078b24f65e6f07a9ab51824..0000000000000000000000000000000000000000
--- a/controller/nucleus/deviceFilesystemStore.go
+++ /dev/null
@@ -1,178 +0,0 @@
-package nucleus
-
-import (
-	"encoding/json"
-	"os"
-	"sync"
-
-	"code.fbi.h-da.de/danet/gosdn/controller/customerrs"
-	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/device"
-	"code.fbi.h-da.de/danet/gosdn/controller/store"
-	"github.com/google/uuid"
-	log "github.com/sirupsen/logrus"
-)
-
-// FilesystemDeviceStore is the filesystem implementation of the device store.
-type FilesystemDeviceStore struct {
-	pndUUID          uuid.UUID
-	fileMutex        sync.Mutex
-	pathToDeviceFile string
-}
-
-// NewFilesystemDeviceStore returns a filesystem implementation for a pnd store.
-func NewFilesystemDeviceStore(pndUUID uuid.UUID) device.Store {
-	deviceFilenameForUUID := store.GetStoreFilenameForUUID(pndUUID, store.DeviceFilenameSuffix)
-
-	if err := store.EnsureFilesystemStorePathExists(deviceFilenameForUUID); err != nil {
-		log.Error(err)
-	}
-	return &FilesystemDeviceStore{
-		pathToDeviceFile: store.GetCompletePathToFileStore(deviceFilenameForUUID),
-		fileMutex:        sync.Mutex{},
-		pndUUID:          pndUUID,
-	}
-}
-
-func (s *FilesystemDeviceStore) readAllDevicesFromFile() ([]device.LoadedDevice, error) {
-	var loadedDevices []device.LoadedDevice
-
-	content, err := os.ReadFile(s.pathToDeviceFile)
-	if err != nil {
-		return nil, err
-	}
-
-	err = json.Unmarshal(content, &loadedDevices)
-	if err != nil {
-		return nil, err
-	}
-
-	return loadedDevices, nil
-}
-
-func (s *FilesystemDeviceStore) writeAllDevicesToFile(devices []device.LoadedDevice) error {
-	serializedData, err := json.Marshal(devices)
-	if err != nil {
-		return err
-	}
-
-	err = os.WriteFile(s.pathToDeviceFile, serializedData, 0600)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// Get takes a Device's UUID or name and returns the Device.
-func (s *FilesystemDeviceStore) Get(query store.Query) (device.LoadedDevice, error) {
-	s.fileMutex.Lock()
-	defer s.fileMutex.Unlock()
-
-	var device device.LoadedDevice
-
-	devices, err := s.readAllDevicesFromFile()
-	if err != nil {
-		return device, err
-	}
-
-	for _, device := range devices {
-		if device.ID == query.ID.String() || device.Name == query.Name {
-			return device, nil
-		}
-	}
-
-	return device, &customerrs.CouldNotFindError{ID: query.ID, Name: query.Name}
-}
-
-// GetAll returns all stored devices.
-func (s *FilesystemDeviceStore) GetAll() ([]device.LoadedDevice, error) {
-	s.fileMutex.Lock()
-	defer s.fileMutex.Unlock()
-
-	devices, err := s.readAllDevicesFromFile()
-
-	return devices, err
-}
-
-// Add adds a device to the device store.
-func (s *FilesystemDeviceStore) Add(deviceToAdd device.Device) error {
-	s.fileMutex.Lock()
-	defer s.fileMutex.Unlock()
-
-	devices, err := s.readAllDevicesFromFile()
-	if err != nil {
-		return err
-	}
-
-	var loadedDevice device.LoadedDevice
-	loadedDevice, err = store.TransformObjectToLoadedObject[device.Device, device.LoadedDevice](deviceToAdd)
-	if err != nil {
-		return err
-	}
-
-	devices = append(devices, loadedDevice)
-
-	err = s.writeAllDevicesToFile(devices)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// Update updates a existing device.
-func (s *FilesystemDeviceStore) Update(deviceToUpdate device.Device) error {
-	s.fileMutex.Lock()
-	defer s.fileMutex.Unlock()
-
-	loadedDeviceToUpdate, err := store.TransformObjectToLoadedObject[device.Device, device.LoadedDevice](deviceToUpdate)
-	if err != nil {
-		return err
-	}
-
-	devices, err := s.readAllDevicesFromFile()
-	if err != nil {
-		return err
-	}
-
-	for i, device := range devices {
-		if device.ID == deviceToUpdate.ID().String() {
-			devices[i] = loadedDeviceToUpdate
-			err = s.writeAllDevicesToFile(devices)
-			if err != nil {
-				return err
-			}
-			return nil
-		}
-	}
-
-	return &customerrs.CouldNotUpdateError{Identifier: deviceToUpdate.ID(), Type: deviceToUpdate, Err: err}
-}
-
-// Delete deletes a device from the device store.
-func (s *FilesystemDeviceStore) Delete(deviceToDelete device.Device) error {
-	s.fileMutex.Lock()
-	defer s.fileMutex.Unlock()
-
-	devices, err := s.readAllDevicesFromFile()
-	if err != nil {
-		return err
-	}
-
-	for i, device := range devices {
-		if device.ID == deviceToDelete.ID().String() {
-			//remove item from slice
-			devices[i] = devices[len(devices)-1]
-			devices = devices[:len(devices)-1]
-
-			err = s.writeAllDevicesToFile(devices)
-			if err != nil {
-				return err
-			}
-
-			return nil
-		}
-	}
-
-	return &customerrs.CouldNotDeleteError{Identifier: deviceToDelete.ID(), Type: deviceToDelete, Err: err}
-}
diff --git a/controller/nucleus/deviceFilesystemStore_test.go b/controller/nucleus/deviceFilesystemStore_test.go
deleted file mode 100644
index 7ff4d15e0203e1f64dcfa004422491aac5f77daa..0000000000000000000000000000000000000000
--- a/controller/nucleus/deviceFilesystemStore_test.go
+++ /dev/null
@@ -1,244 +0,0 @@
-package nucleus
-
-import (
-	"testing"
-
-	spb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/southbound"
-	tpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/transport"
-	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/device"
-	"code.fbi.h-da.de/danet/gosdn/controller/store"
-	"github.com/google/uuid"
-)
-
-func returnBasicTransportOption() tpb.TransportOption {
-	return tpb.TransportOption{
-		Address:  "test:///",
-		Username: "test",
-		Password: "test",
-		TransportOption: &tpb.TransportOption_GnmiTransportOption{
-			GnmiTransportOption: &tpb.GnmiTransportOption{
-				Compression:     "",
-				GrpcDialOptions: nil,
-				Token:           "",
-				Encoding:        0,
-			},
-		},
-	}
-}
-
-func TestAddDevice(t *testing.T) {
-	defer ensureStoreFileForTestsIsRemoved(store.DeviceFilenameSuffix)
-
-	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
-	deviceID, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
-	sbiID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
-	trop := returnBasicTransportOption()
-
-	sbi1, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID1)
-
-	deviceStore := NewNetworkElementStore(pndID)
-	device, _ := NewNetworkElement("testdevice", deviceID, &trop, sbi1)
-
-	err := deviceStore.Add(device)
-	if err != nil {
-		t.Error(err)
-	}
-}
-
-func TestGetAllDevices(t *testing.T) {
-	defer ensureStoreFileForTestsIsRemoved(store.DeviceFilenameSuffix)
-
-	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
-	deviceStore := NewNetworkElementStore(pndID)
-
-	sbiID, _ := uuid.Parse("ssssssss-ssss-ssss-ssss-ssssssssssss")
-	sbi, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID)
-
-	deviceID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
-	deviceID2, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaab")
-
-	transportOptions := returnBasicTransportOption()
-
-	device1, err := NewNetworkElement("testname", deviceID1, &transportOptions, sbi)
-	if err != nil {
-		t.Error(err)
-	}
-
-	device2, err := NewNetworkElement("testname2", deviceID2, &transportOptions, sbi)
-	if err != nil {
-		t.Error(err)
-	}
-
-	inputDevices := [2]device.Device{device1, device2}
-
-	for _, device := range inputDevices {
-		err := deviceStore.Add(device)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-	returnedDevices, err := deviceStore.GetAll()
-	if err != nil {
-		t.Error(err)
-	}
-
-	length := len(returnedDevices)
-	if length != 2 {
-		t.Errorf("GetAll() length of array = %v, want %v", length, 2)
-	}
-
-	for i, device := range returnedDevices {
-		if device.ID != inputDevices[i].ID().String() {
-			t.Errorf("GetAll() = %v, want %v", device.ID, inputDevices[i].ID().String())
-		}
-		if device.Name != inputDevices[i].Name() {
-			t.Errorf("GetAll() = %v, want %v", device.Name, inputDevices[i].Name())
-		}
-	}
-}
-
-func TestGetDevice(t *testing.T) {
-	defer ensureStoreFileForTestsIsRemoved(store.DeviceFilenameSuffix)
-
-	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
-	deviceStore := NewNetworkElementStore(pndID)
-
-	sbiID, _ := uuid.Parse("ssssssss-ssss-ssss-ssss-ssssssssssss")
-	sbi, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID)
-
-	deviceID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
-	deviceID2, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaab")
-
-	trop := returnBasicTransportOption()
-
-	device1, err := NewNetworkElement("testname", deviceID1, &trop, sbi)
-	if err != nil {
-		t.Error(err)
-	}
-
-	device2, err := NewNetworkElement("testname2", deviceID2, &trop, sbi)
-	if err != nil {
-		t.Error(err)
-	}
-
-	inputDevices := [2]device.Device{device1, device2}
-
-	for _, device := range inputDevices {
-		err := deviceStore.Add(device)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-	returnDevice, err := deviceStore.Get(store.Query{ID: deviceID2, Name: "testname2"})
-	if err != nil {
-		t.Error(err)
-	}
-
-	if returnDevice.ID != inputDevices[1].ID().String() {
-		t.Errorf("Get() = %v, want %v", returnDevice.ID, inputDevices[1].ID().String())
-	}
-	if returnDevice.Name != inputDevices[1].Name() {
-		t.Errorf("Get() = %v, want %v", returnDevice.Name, inputDevices[1].Name())
-	}
-}
-
-func TestUpdateDevice(t *testing.T) {
-	defer ensureStoreFileForTestsIsRemoved(store.DeviceFilenameSuffix)
-
-	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
-	deviceID, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
-	sbiID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
-
-	trop := returnBasicTransportOption()
-
-	updatedDeviceName := "testdevice2"
-
-	sbi1, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID1)
-
-	deviceStore := NewNetworkElementStore(pndID)
-	device, _ := NewNetworkElement("testdevice", deviceID, &trop, sbi1)
-
-	err := deviceStore.Add(device)
-	if err != nil {
-		t.Error(err)
-	}
-
-	device, _ = NewNetworkElement(updatedDeviceName, deviceID, &trop, sbi1)
-
-	err = deviceStore.Update(device)
-	if err != nil {
-		t.Error(err)
-	}
-
-	returnDevice, err := deviceStore.Get(store.Query{ID: deviceID, Name: updatedDeviceName})
-	if err != nil {
-		t.Error(err)
-	}
-
-	if returnDevice.ID != deviceID.String() {
-		t.Errorf("Get() = %v, want %v", returnDevice.ID, deviceID.String())
-	}
-	if returnDevice.Name != updatedDeviceName {
-		t.Errorf("Get() = %v, want %v", returnDevice.Name, updatedDeviceName)
-	}
-}
-
-func TestDeleteDevice(t *testing.T) {
-	defer ensureStoreFileForTestsIsRemoved(store.DeviceFilenameSuffix)
-
-	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
-	deviceStore := NewNetworkElementStore(pndID)
-
-	sbiID, _ := uuid.Parse("ssssssss-ssss-ssss-ssss-ssssssssssss")
-	sbi, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID)
-
-	deviceID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
-	deviceID2, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaab")
-
-	trop := returnBasicTransportOption()
-
-	device1, err := NewNetworkElement("testname", deviceID1, &trop, sbi)
-	if err != nil {
-		t.Error(err)
-	}
-
-	device2, err := NewNetworkElement("testname2", deviceID2, &trop, sbi)
-	if err != nil {
-		t.Error(err)
-	}
-
-	inputDevices := [2]device.Device{device1, device2}
-
-	for _, device := range inputDevices {
-		err := deviceStore.Add(device)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-	err = deviceStore.Delete(device1)
-	if err != nil {
-		t.Error(err)
-	}
-
-	returnDevices, err := deviceStore.GetAll()
-	if err != nil {
-		t.Error(err)
-	}
-
-	length := len(returnDevices)
-	if length != 1 {
-		t.Errorf("GetAll() length of array = %v, want %v", length, 2)
-	}
-
-	for _, device := range returnDevices {
-		if device.ID != inputDevices[1].ID().String() {
-			t.Errorf("GetAll() = %v, want %v", device.ID, inputDevices[1].ID().String())
-		}
-		if device.Name != inputDevices[1].Name() {
-			t.Errorf("GetAll() = %v, want %v", device.Name, inputDevices[1].Name())
-		}
-	}
-}
diff --git a/controller/nucleus/deviceService_test.go b/controller/nucleus/deviceService_test.go
deleted file mode 100644
index bbd905f57b0b57d5d21c7f6ff54e1d5d19f68710..0000000000000000000000000000000000000000
--- a/controller/nucleus/deviceService_test.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package nucleus
-
-import (
-	"testing"
-
-	eventservice "code.fbi.h-da.de/danet/gosdn/controller/eventService"
-	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/device"
-	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/southbound"
-	"code.fbi.h-da.de/danet/gosdn/controller/mocks"
-	"code.fbi.h-da.de/danet/gosdn/controller/store"
-	"github.com/google/uuid"
-
-	spb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/southbound"
-)
-
-func getMockDevice(deviceID uuid.UUID, sbi southbound.SouthboundInterface) device.Device {
-	return &CommonNetworkElement{
-		UUID:      deviceID,
-		Model:     sbi.Schema().Root,
-		sbi:       sbi,
-		transport: &mocks.Transport{},
-	}
-}
-
-func getDeviceTestStores(t *testing.T, deviceID uuid.UUID) (device.Service, southbound.Service, device.Device, southbound.SouthboundInterface) {
-	eventService := eventservice.NewMockEventService()
-	sbiStore := NewMemorySbiStore()
-	deviceStore := NewMemoryDeviceStore()
-	sbiService := NewSbiService(sbiStore, eventService)
-	deviceService := NewNetworkElementService(
-		deviceStore,
-		sbiService,
-		eventService,
-	)
-
-	sbi, err := NewSBI(spb.Type_TYPE_OPENCONFIG)
-	if err != nil {
-		t.Error("could not create sbi")
-	}
-
-	err = sbiService.Add(sbi)
-	if err != nil {
-		t.Error("could not add sbi")
-	}
-
-	mockDevice := getMockDevice(deviceID, sbi)
-	err = deviceService.Add(mockDevice)
-	if err != nil {
-		t.Error("could not add device")
-	}
-
-	return deviceService, sbiService, mockDevice, sbi
-}
-
-func TestDeviceService_Get(t *testing.T) {
-	deviceID := uuid.New()
-
-	deviceService, _, mockDevice, _ := getDeviceTestStores(t, deviceID)
-
-	device, err := deviceService.Get(store.Query{
-		ID:   mockDevice.ID(),
-		Name: mockDevice.Name(),
-	})
-	if err != nil {
-		t.Error("could not get device")
-	}
-
-	if mockDevice.ID() != device.ID() {
-		t.Errorf("Expected ID=%s, got %s", mockDevice.ID(), device.ID())
-	}
-}
-
-func TestDeviceService_Delete(t *testing.T) {
-	deviceID := uuid.New()
-
-	deviceService, _, mockDevice, _ := getDeviceTestStores(t, deviceID)
-
-	device, err := deviceService.Get(store.Query{
-		ID:   mockDevice.ID(),
-		Name: mockDevice.Name(),
-	})
-	if err != nil {
-		t.Error("could not get device")
-	}
-
-	err = deviceService.Delete(device)
-	if err != nil {
-		t.Error("could not delete device")
-	}
-}
-
-func TestDeviceService_GetAll(t *testing.T) {
-	deviceID := uuid.New()
-	deviceID2 := uuid.New()
-
-	deviceService, _, _, sbi := getDeviceTestStores(t, deviceID)
-	mockDevice2 := getMockDevice(deviceID2, sbi)
-
-	err := deviceService.Add(mockDevice2)
-	if err != nil {
-		t.Error("could not add device")
-	}
-
-	devices, err := deviceService.GetAll()
-	if err != nil {
-		t.Error("could not get all devices")
-	}
-
-	if len(devices) != 2 {
-		t.Errorf("Expected len(devices)=2, got %d", len(devices))
-	}
-}
diff --git a/controller/nucleus/initialise_test.go b/controller/nucleus/initialise_test.go
index a3f4d57a8426bb3238868e0382abf5c745abebb2..6a66fc3fabb5c3296c91cf255b7fe4475ea01e1b 100644
--- a/controller/nucleus/initialise_test.go
+++ b/controller/nucleus/initialise_test.go
@@ -11,8 +11,8 @@ import (
 	eventservice "code.fbi.h-da.de/danet/gosdn/controller/eventService"
 	"code.fbi.h-da.de/danet/gosdn/controller/store"
 
-	"code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement"
 	tpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/transport"
+	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkelement"
 
 	"code.fbi.h-da.de/danet/gosdn/controller/mocks"
 	"code.fbi.h-da.de/danet/gosdn/controller/nucleus/util/proto"
@@ -156,7 +156,7 @@ func newPnd() pndImplementation {
 	eventService := eventservice.NewMockEventService()
 
 	sbiStore := NewMemorySbiStore()
-	deviceStore := NewMemoryDeviceStore()
+	deviceStore := NewMemoryNetworkElementStore()
 	sbiService := NewSbiService(sbiStore, eventService)
 	deviceService := NewNetworkElementService(
 		deviceStore,
diff --git a/controller/nucleus/memoryDeviceStore.go b/controller/nucleus/memoryDeviceStore.go
index aa2f94ff4b8597b65370499673d38d37c62aea52..100410af71bffe51c7e8f46404194d2e780f4a73 100644
--- a/controller/nucleus/memoryDeviceStore.go
+++ b/controller/nucleus/memoryDeviceStore.go
@@ -8,14 +8,14 @@ import (
 	"code.fbi.h-da.de/danet/gosdn/controller/store"
 )
 
-// MemoryNetworkElementStore provides a in-memory implementation for devices.
+// MemoryNetworkElementStore provides a in-memory implementation for network elements.
 type MemoryNetworkElementStore struct {
 	Store           map[string]networkelement.LoadedNetworkElement
 	nameLookupTable map[string]string
 }
 
-// NewMemoryDeviceStore returns a specific in-memory store for devices.
-func NewMemoryDeviceStore() networkelement.Store {
+// NewMemoryNetworkElementStore returns a specific in-memory store for network elements.
+func NewMemoryNetworkElementStore() networkelement.Store {
 	return &MemoryNetworkElementStore{
 		Store:           make(map[string]networkelement.LoadedNetworkElement),
 		nameLookupTable: make(map[string]string),
@@ -99,7 +99,7 @@ func (t *MemoryNetworkElementStore) Get(query store.Query) (networkelement.Loade
 	return item, nil
 }
 
-// GetAll returns all stored devices.
+// GetAll returns all stored network elements.
 func (t *MemoryNetworkElementStore) GetAll() ([]networkelement.LoadedNetworkElement, error) {
 	var allItems []networkelement.LoadedNetworkElement
 
diff --git a/controller/nucleus/networkElementFilesystemStore.go b/controller/nucleus/networkElementFilesystemStore.go
new file mode 100644
index 0000000000000000000000000000000000000000..251fb229a59af45d4d125d5f8f72991f5b40dad2
--- /dev/null
+++ b/controller/nucleus/networkElementFilesystemStore.go
@@ -0,0 +1,178 @@
+package nucleus
+
+import (
+	"encoding/json"
+	"os"
+	"sync"
+
+	"code.fbi.h-da.de/danet/gosdn/controller/customerrs"
+	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkelement"
+	"code.fbi.h-da.de/danet/gosdn/controller/store"
+	"github.com/google/uuid"
+	log "github.com/sirupsen/logrus"
+)
+
+// FilesystemNetworkElementStore is the filesystem implementation of the network element store.
+type FilesystemNetworkElementStore struct {
+	pndUUID                  uuid.UUID
+	fileMutex                sync.Mutex
+	pathToNetworkElementFile string
+}
+
+// NewFilesystemNetworkElementStore returns a filesystem implementation for a pnd store.
+func NewFilesystemNetworkElementStore(pndUUID uuid.UUID) networkelement.Store {
+	networkElementFilenameForUUID := store.GetStoreFilenameForUUID(pndUUID, store.NetworkElementFilenameSuffix)
+
+	if err := store.EnsureFilesystemStorePathExists(networkElementFilenameForUUID); err != nil {
+		log.Error(err)
+	}
+	return &FilesystemNetworkElementStore{
+		pathToNetworkElementFile: store.GetCompletePathToFileStore(networkElementFilenameForUUID),
+		fileMutex:                sync.Mutex{},
+		pndUUID:                  pndUUID,
+	}
+}
+
+func (s *FilesystemNetworkElementStore) readAllNetworkElementsFromFile() ([]networkelement.LoadedNetworkElement, error) {
+	var loadedNetworkElements []networkelement.LoadedNetworkElement
+
+	content, err := os.ReadFile(s.pathToNetworkElementFile)
+	if err != nil {
+		return nil, err
+	}
+
+	err = json.Unmarshal(content, &loadedNetworkElements)
+	if err != nil {
+		return nil, err
+	}
+
+	return loadedNetworkElements, nil
+}
+
+func (s *FilesystemNetworkElementStore) writeAllNetworkElementsToFile(mnes []networkelement.LoadedNetworkElement) error {
+	serializedData, err := json.Marshal(mnes)
+	if err != nil {
+		return err
+	}
+
+	err = os.WriteFile(s.pathToNetworkElementFile, serializedData, 0600)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Get takes a network element's UUID or name and returns the network element.
+func (s *FilesystemNetworkElementStore) Get(query store.Query) (networkelement.LoadedNetworkElement, error) {
+	s.fileMutex.Lock()
+	defer s.fileMutex.Unlock()
+
+	var lMNE networkelement.LoadedNetworkElement
+
+	mnes, err := s.readAllNetworkElementsFromFile()
+	if err != nil {
+		return lMNE, err
+	}
+
+	for _, mne := range mnes {
+		if mne.ID == query.ID.String() || mne.Name == query.Name {
+			return mne, nil
+		}
+	}
+
+	return lMNE, &customerrs.CouldNotFindError{ID: query.ID, Name: query.Name}
+}
+
+// GetAll returns all stored network elements.
+func (s *FilesystemNetworkElementStore) GetAll() ([]networkelement.LoadedNetworkElement, error) {
+	s.fileMutex.Lock()
+	defer s.fileMutex.Unlock()
+
+	mnes, err := s.readAllNetworkElementsFromFile()
+
+	return mnes, err
+}
+
+// Add adds a network element to the network element store.
+func (s *FilesystemNetworkElementStore) Add(networkElementToAdd networkelement.NetworkElement) error {
+	s.fileMutex.Lock()
+	defer s.fileMutex.Unlock()
+
+	mnes, err := s.readAllNetworkElementsFromFile()
+	if err != nil {
+		return err
+	}
+
+	var loadedNetworkElement networkelement.LoadedNetworkElement
+	loadedNetworkElement, err = store.TransformObjectToLoadedObject[networkelement.NetworkElement, networkelement.LoadedNetworkElement](networkElementToAdd)
+	if err != nil {
+		return err
+	}
+
+	mnes = append(mnes, loadedNetworkElement)
+
+	err = s.writeAllNetworkElementsToFile(mnes)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Update updates a existing network element.
+func (s *FilesystemNetworkElementStore) Update(networkElementToUpdate networkelement.NetworkElement) error {
+	s.fileMutex.Lock()
+	defer s.fileMutex.Unlock()
+
+	loadedNetworkElementToUpdate, err := store.TransformObjectToLoadedObject[networkelement.NetworkElement, networkelement.LoadedNetworkElement](networkElementToUpdate)
+	if err != nil {
+		return err
+	}
+
+	mnes, err := s.readAllNetworkElementsFromFile()
+	if err != nil {
+		return err
+	}
+
+	for i, mne := range mnes {
+		if mne.ID == networkElementToUpdate.ID().String() {
+			mnes[i] = loadedNetworkElementToUpdate
+			err = s.writeAllNetworkElementsToFile(mnes)
+			if err != nil {
+				return err
+			}
+			return nil
+		}
+	}
+
+	return &customerrs.CouldNotUpdateError{Identifier: networkElementToUpdate.ID(), Type: networkElementToUpdate, Err: err}
+}
+
+// Delete deletes a network element from the network element store.
+func (s *FilesystemNetworkElementStore) Delete(networkElementToDelete networkelement.NetworkElement) error {
+	s.fileMutex.Lock()
+	defer s.fileMutex.Unlock()
+
+	mnes, err := s.readAllNetworkElementsFromFile()
+	if err != nil {
+		return err
+	}
+
+	for i, mne := range mnes {
+		if mne.ID == networkElementToDelete.ID().String() {
+			//remove item from slice
+			mnes[i] = mnes[len(mnes)-1]
+			mnes = mnes[:len(mnes)-1]
+
+			err = s.writeAllNetworkElementsToFile(mnes)
+			if err != nil {
+				return err
+			}
+
+			return nil
+		}
+	}
+
+	return &customerrs.CouldNotDeleteError{Identifier: networkElementToDelete.ID(), Type: networkElementToDelete, Err: err}
+}
diff --git a/controller/nucleus/networkElementFilesystemStore_test.go b/controller/nucleus/networkElementFilesystemStore_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0b6ba8a3193599a741417b8eec19c3b7e5fd7d21
--- /dev/null
+++ b/controller/nucleus/networkElementFilesystemStore_test.go
@@ -0,0 +1,244 @@
+package nucleus
+
+import (
+	"testing"
+
+	spb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/southbound"
+	tpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/transport"
+	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkelement"
+	"code.fbi.h-da.de/danet/gosdn/controller/store"
+	"github.com/google/uuid"
+)
+
+func returnBasicTransportOption() tpb.TransportOption {
+	return tpb.TransportOption{
+		Address:  "test:///",
+		Username: "test",
+		Password: "test",
+		TransportOption: &tpb.TransportOption_GnmiTransportOption{
+			GnmiTransportOption: &tpb.GnmiTransportOption{
+				Compression:     "",
+				GrpcDialOptions: nil,
+				Token:           "",
+				Encoding:        0,
+			},
+		},
+	}
+}
+
+func TestAddNetworkElement(t *testing.T) {
+	defer ensureStoreFileForTestsIsRemoved(store.NetworkElementFilenameSuffix)
+
+	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
+	mneID, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+	sbiID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+	trop := returnBasicTransportOption()
+
+	sbi1, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID1)
+
+	networkElementStore := NewNetworkElementStore(pndID)
+	mne, _ := NewNetworkElement("testNetworkElement", mneID, &trop, sbi1)
+
+	err := networkElementStore.Add(mne)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestGetAllNetworkElements(t *testing.T) {
+	defer ensureStoreFileForTestsIsRemoved(store.NetworkElementFilenameSuffix)
+
+	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
+	networkElementStore := NewNetworkElementStore(pndID)
+
+	sbiID, _ := uuid.Parse("ssssssss-ssss-ssss-ssss-ssssssssssss")
+	sbi, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID)
+
+	mneID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+	mneID2, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaab")
+
+	transportOptions := returnBasicTransportOption()
+
+	mne1, err := NewNetworkElement("testname", mneID1, &transportOptions, sbi)
+	if err != nil {
+		t.Error(err)
+	}
+
+	mne2, err := NewNetworkElement("testname2", mneID2, &transportOptions, sbi)
+	if err != nil {
+		t.Error(err)
+	}
+
+	inputNetworkElements := [2]networkelement.NetworkElement{mne1, mne2}
+
+	for _, mne := range inputNetworkElements {
+		err := networkElementStore.Add(mne)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	returnedNetworkElements, err := networkElementStore.GetAll()
+	if err != nil {
+		t.Error(err)
+	}
+
+	length := len(returnedNetworkElements)
+	if length != 2 {
+		t.Errorf("GetAll() length of array = %v, want %v", length, 2)
+	}
+
+	for i, mne := range returnedNetworkElements {
+		if mne.ID != inputNetworkElements[i].ID().String() {
+			t.Errorf("GetAll() = %v, want %v", mne.ID, inputNetworkElements[i].ID().String())
+		}
+		if mne.Name != inputNetworkElements[i].Name() {
+			t.Errorf("GetAll() = %v, want %v", mne.Name, inputNetworkElements[i].Name())
+		}
+	}
+}
+
+func TestGetNetworkElement(t *testing.T) {
+	defer ensureStoreFileForTestsIsRemoved(store.NetworkElementFilenameSuffix)
+
+	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
+	networkElementStore := NewNetworkElementStore(pndID)
+
+	sbiID, _ := uuid.Parse("ssssssss-ssss-ssss-ssss-ssssssssssss")
+	sbi, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID)
+
+	mneID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+	mneID2, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaab")
+
+	trop := returnBasicTransportOption()
+
+	mne1, err := NewNetworkElement("testname", mneID1, &trop, sbi)
+	if err != nil {
+		t.Error(err)
+	}
+
+	mne2, err := NewNetworkElement("testname2", mneID2, &trop, sbi)
+	if err != nil {
+		t.Error(err)
+	}
+
+	inputNetworkElements := [2]networkelement.NetworkElement{mne1, mne2}
+
+	for _, mne := range inputNetworkElements {
+		err := networkElementStore.Add(mne)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	returnNetworkElement, err := networkElementStore.Get(store.Query{ID: mneID2, Name: "testname2"})
+	if err != nil {
+		t.Error(err)
+	}
+
+	if returnNetworkElement.ID != inputNetworkElements[1].ID().String() {
+		t.Errorf("Get() = %v, want %v", returnNetworkElement.ID, inputNetworkElements[1].ID().String())
+	}
+	if returnNetworkElement.Name != inputNetworkElements[1].Name() {
+		t.Errorf("Get() = %v, want %v", returnNetworkElement.Name, inputNetworkElements[1].Name())
+	}
+}
+
+func TestUpdateNetworkElement(t *testing.T) {
+	defer ensureStoreFileForTestsIsRemoved(store.NetworkElementFilenameSuffix)
+
+	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
+	mneID, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+	sbiID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+
+	trop := returnBasicTransportOption()
+
+	updatedNetworkElementName := "testNetworkElement2"
+
+	sbi1, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID1)
+
+	networkElementStore := NewNetworkElementStore(pndID)
+	mne, _ := NewNetworkElement("testNetworkElement", mneID, &trop, sbi1)
+
+	err := networkElementStore.Add(mne)
+	if err != nil {
+		t.Error(err)
+	}
+
+	mne, _ = NewNetworkElement(updatedNetworkElementName, mneID, &trop, sbi1)
+
+	err = networkElementStore.Update(mne)
+	if err != nil {
+		t.Error(err)
+	}
+
+	returnNetworkElement, err := networkElementStore.Get(store.Query{ID: mneID, Name: updatedNetworkElementName})
+	if err != nil {
+		t.Error(err)
+	}
+
+	if returnNetworkElement.ID != mneID.String() {
+		t.Errorf("Get() = %v, want %v", returnNetworkElement.ID, mneID.String())
+	}
+	if returnNetworkElement.Name != updatedNetworkElementName {
+		t.Errorf("Get() = %v, want %v", returnNetworkElement.Name, updatedNetworkElementName)
+	}
+}
+
+func TestDeleteNetworkElement(t *testing.T) {
+	defer ensureStoreFileForTestsIsRemoved(store.NetworkElementFilenameSuffix)
+
+	pndID, _ := uuid.Parse("b4016412-eec5-45a1-aa29-f59915357bad")
+	networkElementStore := NewNetworkElementStore(pndID)
+
+	sbiID, _ := uuid.Parse("ssssssss-ssss-ssss-ssss-ssssssssssss")
+	sbi, _ := NewSBI(spb.Type_TYPE_OPENCONFIG, sbiID)
+
+	mneID1, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
+	mneID2, _ := uuid.Parse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaab")
+
+	trop := returnBasicTransportOption()
+
+	mne1, err := NewNetworkElement("testname", mneID1, &trop, sbi)
+	if err != nil {
+		t.Error(err)
+	}
+
+	mne2, err := NewNetworkElement("testname2", mneID2, &trop, sbi)
+	if err != nil {
+		t.Error(err)
+	}
+
+	inputNetworkElements := [2]networkelement.NetworkElement{mne1, mne2}
+
+	for _, mne := range inputNetworkElements {
+		err := networkElementStore.Add(mne)
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	err = networkElementStore.Delete(mne1)
+	if err != nil {
+		t.Error(err)
+	}
+
+	returnNetworkElements, err := networkElementStore.GetAll()
+	if err != nil {
+		t.Error(err)
+	}
+
+	length := len(returnNetworkElements)
+	if length != 1 {
+		t.Errorf("GetAll() length of array = %v, want %v", length, 2)
+	}
+
+	for _, mne := range returnNetworkElements {
+		if mne.ID != inputNetworkElements[1].ID().String() {
+			t.Errorf("GetAll() = %v, want %v", mne.ID, inputNetworkElements[1].ID().String())
+		}
+		if mne.Name != inputNetworkElements[1].Name() {
+			t.Errorf("GetAll() = %v, want %v", mne.Name, inputNetworkElements[1].Name())
+		}
+	}
+}
diff --git a/controller/nucleus/networkElementService_test.go b/controller/nucleus/networkElementService_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..39aad46fa30d4cf6c9e5d7bc8619ae4b7cdfc6d6
--- /dev/null
+++ b/controller/nucleus/networkElementService_test.go
@@ -0,0 +1,112 @@
+package nucleus
+
+import (
+	"testing"
+
+	eventservice "code.fbi.h-da.de/danet/gosdn/controller/eventService"
+	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkelement"
+	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/southbound"
+	"code.fbi.h-da.de/danet/gosdn/controller/mocks"
+	"code.fbi.h-da.de/danet/gosdn/controller/store"
+	"github.com/google/uuid"
+
+	spb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/southbound"
+)
+
+func getMockNetworkElement(mneID uuid.UUID, sbi southbound.SouthboundInterface) networkelement.NetworkElement {
+	return &CommonNetworkElement{
+		UUID:      mneID,
+		Model:     sbi.Schema().Root,
+		sbi:       sbi,
+		transport: &mocks.Transport{},
+	}
+}
+
+func getNetworkElementTestStores(t *testing.T, mneID uuid.UUID) (networkelement.Service, southbound.Service, networkelement.NetworkElement, southbound.SouthboundInterface) {
+	eventService := eventservice.NewMockEventService()
+	sbiStore := NewMemorySbiStore()
+	networkElementStore := NewMemoryNetworkElementStore()
+	sbiService := NewSbiService(sbiStore, eventService)
+	networkElementService := NewNetworkElementService(
+		networkElementStore,
+		sbiService,
+		eventService,
+	)
+
+	sbi, err := NewSBI(spb.Type_TYPE_OPENCONFIG)
+	if err != nil {
+		t.Error("could not create sbi")
+	}
+
+	err = sbiService.Add(sbi)
+	if err != nil {
+		t.Error("could not add sbi")
+	}
+
+	mockNetworkElement := getMockNetworkElement(mneID, sbi)
+	err = networkElementService.Add(mockNetworkElement)
+	if err != nil {
+		t.Error("could not add network element")
+	}
+
+	return networkElementService, sbiService, mockNetworkElement, sbi
+}
+
+func TestNetworkElementService_Get(t *testing.T) {
+	mneID := uuid.New()
+
+	networkElementService, _, mockNetworkElement, _ := getNetworkElementTestStores(t, mneID)
+
+	mne, err := networkElementService.Get(store.Query{
+		ID:   mockNetworkElement.ID(),
+		Name: mockNetworkElement.Name(),
+	})
+	if err != nil {
+		t.Error("could not get network element")
+	}
+
+	if mockNetworkElement.ID() != mne.ID() {
+		t.Errorf("Expected ID=%s, got %s", mockNetworkElement.ID(), mne.ID())
+	}
+}
+
+func TestNetworkElementService_Delete(t *testing.T) {
+	mneID := uuid.New()
+
+	networkElementService, _, mockNetworkElement, _ := getNetworkElementTestStores(t, mneID)
+
+	mne, err := networkElementService.Get(store.Query{
+		ID:   mockNetworkElement.ID(),
+		Name: mockNetworkElement.Name(),
+	})
+	if err != nil {
+		t.Error("could not get network element")
+	}
+
+	err = networkElementService.Delete(mne)
+	if err != nil {
+		t.Error("could not delete network element")
+	}
+}
+
+func TestNetworkElementService_GetAll(t *testing.T) {
+	mneID := uuid.New()
+	mneID2 := uuid.New()
+
+	networkElementService, _, _, sbi := getNetworkElementTestStores(t, mneID)
+	mockNetworkElement2 := getMockNetworkElement(mneID2, sbi)
+
+	err := networkElementService.Add(mockNetworkElement2)
+	if err != nil {
+		t.Error("could not add network element")
+	}
+
+	mnes, err := networkElementService.GetAll()
+	if err != nil {
+		t.Error("could not get all network elements")
+	}
+
+	if len(mnes) != 2 {
+		t.Errorf("Expected len(network elements)=2, got %d", len(mnes))
+	}
+}
diff --git a/controller/nucleus/networkElementStore.go b/controller/nucleus/networkElementStore.go
index 173395149e86a4624e328955b23d2accb2a284c6..72b663adbe7a82750386736c77f0987b3e1a12bc 100644
--- a/controller/nucleus/networkElementStore.go
+++ b/controller/nucleus/networkElementStore.go
@@ -22,7 +22,7 @@ func NewNetworkElementStore(pndUUID uuid.UUID) networkelement.Store {
 		}
 
 	default:
-		store := NewFilesystemDeviceStore(pndUUID)
+		store := NewFilesystemNetworkElementStore(pndUUID)
 		return store
 	}
 }
diff --git a/controller/nucleus/sbiFilesystemStore_test.go b/controller/nucleus/sbiFilesystemStore_test.go
index 24ab4dae94443d461fd561f5539434a6fc1d5a17..44d74096a3286f0c931f15d273ba4451639e750a 100644
--- a/controller/nucleus/sbiFilesystemStore_test.go
+++ b/controller/nucleus/sbiFilesystemStore_test.go
@@ -11,7 +11,7 @@ import (
 
 func ensureStoreFilesForTestsAreRemoved() {
 	ensureStoreFileForTestsIsRemoved(store.SbiFilenameSuffix)
-	ensureStoreFileForTestsIsRemoved(store.DeviceFilenameSuffix)
+	ensureStoreFileForTestsIsRemoved(store.NetworkElementFilenameSuffix)
 }
 
 func TestAddSbi(t *testing.T) {
diff --git a/controller/store/filesystem-settings.go b/controller/store/filesystem-settings.go
index cba093e64af2b7ebde453dfc6e553f80bbb2d3b7..cc622e72805349f33e40bc315e6b6d814207559e 100644
--- a/controller/store/filesystem-settings.go
+++ b/controller/store/filesystem-settings.go
@@ -3,8 +3,8 @@ package store
 const (
 	// PndFilename is the name of the file where the pnds are stored.
 	PndFilename string = "pndStore.json"
-	// DeviceFilenameSuffix is the suffix of the file where the devices are stored.
-	DeviceFilenameSuffix string = "deviceStore.json"
+	// NetworkElementFilenameSuffix is the suffix of the file where the network elements are stored.
+	NetworkElementFilenameSuffix string = "networkElementStore.json"
 	// SbiFilenameSuffix is the suffix of the file where the sbis are stored.
 	SbiFilenameSuffix string = "sbiStore.json"
 	// UserFilename is the name of the file where the users are stored.