diff --git a/opendut-carl/src/actions/peers.rs b/opendut-carl/src/actions/peers.rs
index 8b46032b2..0815aaea2 100644
--- a/opendut-carl/src/actions/peers.rs
+++ b/opendut-carl/src/actions/peers.rs
@@ -277,7 +277,7 @@ mod test {
     use rstest::*;
 
     use opendut_types::peer::{PeerLocation, PeerName};
-    use opendut_types::topology::Topology;
+    use opendut_types::topology::{DeviceDescription, DeviceName, Topology};
     use opendut_types::util::net::NetworkInterfaceName;
 
     use crate::resources::manager::ResourcesManager;
@@ -287,6 +287,7 @@ mod test {
     mod store_peer_descriptor {
         use googletest::prelude::*;
         use rstest::*;
+        use opendut_types::topology::{DeviceDescription, DeviceName};
         use opendut_types::util::net::NetworkInterfaceName;
 
         use super::*;
@@ -310,8 +311,8 @@ mod test {
             let additional_device_id = DeviceId::random();
             let additional_device = DeviceDescriptor {
                 id: additional_device_id,
-                name: String::from("PeerA Device 42"),
-                description: String::from("Additional device for peerA"),
+                name: DeviceName::try_from("PeerA_Device_42").unwrap(),
+                description: DeviceDescription::try_from("Additional device for peerA").ok(),
                 interface: NetworkInterfaceName::try_from("eth1").unwrap(),
                 tags: vec![],
             };
@@ -358,20 +359,20 @@ mod test {
         let peer_a_descriptor = PeerDescriptor {
             id: peer_a_id,
             name: PeerName::try_from("PeerA").unwrap(),
-            location: PeerLocation::new("Ulm"),
+            location: PeerLocation::try_from("Ulm").ok(),
             topology: Topology {
                 devices: vec![
                     DeviceDescriptor {
                         id: peer_a_device_1,
-                        name: String::from("PeerA Device 1"),
-                        description: String::from("Huii"),
+                        name: DeviceName::try_from("PeerA_Device_1").unwrap(),
+                        description: DeviceDescription::try_from("Huii").ok(),
                         interface: NetworkInterfaceName::try_from("eth0").unwrap(),
                         tags: vec![],
                     },
                     DeviceDescriptor {
                         id: peer_a_device_2,
-                        name: String::from("PeerA Device 2"),
-                        description: String::from("Huii"),
+                        name: DeviceName::try_from("PeerA_Device_2").unwrap(),
+                        description: DeviceDescription::try_from("Huii").ok(),
                         interface: NetworkInterfaceName::try_from("eth1").unwrap(),
                         tags: vec![],
                     }
diff --git a/opendut-carl/src/cluster/manager.rs b/opendut-carl/src/cluster/manager.rs
index 0e3cf9769..b79b445e0 100644
--- a/opendut-carl/src/cluster/manager.rs
+++ b/opendut-carl/src/cluster/manager.rs
@@ -243,7 +243,7 @@ mod test {
 
     use opendut_types::cluster::ClusterName;
     use opendut_types::peer::{PeerDescriptor, PeerId, PeerLocation, PeerName};
-    use opendut_types::topology::{DeviceDescriptor, DeviceId, Topology};
+    use opendut_types::topology::{DeviceDescription, DeviceDescriptor, DeviceId, DeviceName, Topology};
     use opendut_types::util::net::NetworkInterfaceName;
 
     use crate::actions::{CreateClusterConfigurationParams, StorePeerDescriptorParams};
@@ -274,13 +274,13 @@ mod test {
         let peer_a = PeerDescriptor {
             id: peer_a_id,
             name: PeerName::try_from("PeerA").unwrap(),
-            location: PeerLocation::new("Ulm"),
+            location: PeerLocation::try_from("Ulm").ok(),
             topology: Topology {
                 devices: vec![
                     DeviceDescriptor {
                         id: peer_a_device_1,
-                        name: String::from("PeerA Device 1"),
-                        description: String::from("Huii"),
+                        name: DeviceName::try_from("PeerA_Device_1").unwrap(),
+                        description: DeviceDescription::try_from("Huii").ok(),
                         interface: NetworkInterfaceName::try_from("eth0").unwrap(),
                         tags: vec![],
                     }
@@ -293,13 +293,13 @@ mod test {
         let peer_b = PeerDescriptor {
             id: peer_b_id,
             name: PeerName::try_from("PeerB").unwrap(),
-            location: PeerLocation::new("Ulm"),
+            location: PeerLocation::try_from("Ulm").ok(),
             topology: Topology {
                 devices: vec![
                     DeviceDescriptor {
                         id: peer_b_device_1,
-                        name: String::from("PeerB Device 1"),
-                        description: String::from("Pfuii"),
+                        name: DeviceName::try_from("PeerB_Device_1").unwrap(),
+                        description: DeviceDescription::try_from("Pfuii").ok(),
                         interface: NetworkInterfaceName::try_from("can1").unwrap(),
                         tags: vec![],
                     }
@@ -402,8 +402,8 @@ mod test {
         fn device(id: DeviceId, interface: NetworkInterfaceName) -> DeviceDescriptor {
             DeviceDescriptor {
                 id,
-                name: format!("test-device-{id}"),
-                description: String::new(),
+                name: DeviceName::try_from(format!("test-device-{id}")).unwrap(),
+                description: None,
                 interface,
                 tags: Vec::new(),
             }
@@ -419,7 +419,7 @@ mod test {
             PeerDescriptor {
                 id,
                 name: PeerName::try_from(format!("peer-{id}")).unwrap(),
-                location: PeerLocation::new("Ulm"),
+                location: PeerLocation::try_from("Ulm").ok(),
                 topology: Topology {
                     devices,
                 },
diff --git a/opendut-carl/src/grpc/peer_manager.rs b/opendut-carl/src/grpc/peer_manager.rs
index 94469a02a..42bb8075e 100644
--- a/opendut-carl/src/grpc/peer_manager.rs
+++ b/opendut-carl/src/grpc/peer_manager.rs
@@ -238,7 +238,7 @@ mod tests {
         let peer_descriptor = PeerDescriptor {
             id: peer_id,
             name: PeerName::try_from("TestPeer").unwrap(),
-            location: PeerLocation::new("SiFi"),
+            location: PeerLocation::try_from("SiFi").ok(),
             topology: Topology::default(),
         };
 
diff --git a/opendut-carl/src/resources/manager.rs b/opendut-carl/src/resources/manager.rs
index c14c0368a..0a49e9214 100644
--- a/opendut-carl/src/resources/manager.rs
+++ b/opendut-carl/src/resources/manager.rs
@@ -99,7 +99,7 @@ mod test {
         let peer = PeerDescriptor {
             id: peer_resource_id,
             name: PeerName::try_from("TestPeer").unwrap(),
-            location: PeerLocation::new("Ulm"),
+            location: PeerLocation::try_from("Ulm").ok(),
             topology: Topology::default(),
         };
 
diff --git a/opendut-cleo/src/commands/cluster_configuration.rs b/opendut-cleo/src/commands/cluster_configuration.rs
index f1bd8c930..9795849b0 100644
--- a/opendut-cleo/src/commands/cluster_configuration.rs
+++ b/opendut-cleo/src/commands/cluster_configuration.rs
@@ -59,7 +59,7 @@ pub mod create {
 
     fn check_devices(all_devices: &[DeviceDescriptor], device_names: &[String]) -> Vec<Result<DeviceDescriptor, crate::Error>> {
         let checked_devices = device_names.iter().map(|device_name| {
-            let maybe_device = all_devices.iter().find(|device| &device.name == device_name);
+            let maybe_device = all_devices.iter().find(|device| &String::from(device.name.value()) == device_name);
             if let Some(device) = maybe_device {
                 Ok(Clone::clone(device))
             }
@@ -76,7 +76,7 @@ pub mod create {
         use super::*;
         use googletest::prelude::*;
         use rstest::{fixture, rstest};
-        use opendut_types::topology::DeviceId;
+        use opendut_types::topology::{DeviceDescription, DeviceId, DeviceName};
         use opendut_types::util::net::NetworkInterfaceName;
 
         #[fixture]
@@ -84,22 +84,22 @@ pub mod create {
             vec![
                 DeviceDescriptor {
                     id: DeviceId::random(),
-                    name: String::from("MyDevice"),
-                    description: String::new(),
+                    name: DeviceName::try_from("MyDevice").unwrap(),
+                    description: DeviceDescription::try_from("").ok(),
                     interface: NetworkInterfaceName::try_from("eth0").unwrap(),
                     tags: vec![],
                 },
                 DeviceDescriptor {
                     id: DeviceId::random(),
-                    name: String::from("YourDevice"),
-                    description: String::new(),
+                    name: DeviceName::try_from("YourDevice").unwrap(),
+                    description: DeviceDescription::try_from("").ok(),
                     interface: NetworkInterfaceName::try_from("eth0").unwrap(),
                     tags: vec![],
                 },
                 DeviceDescriptor {
                     id: DeviceId::random(),
-                    name: String::from("HisDevice"),
-                    description: String::new(),
+                    name: DeviceName::try_from("HisDevice").unwrap(),
+                    description: DeviceDescription::try_from("").ok(),
                     interface: NetworkInterfaceName::try_from("eth0").unwrap(),
                     tags: vec![],
                 }
@@ -202,8 +202,9 @@ pub mod describe {
 
     use opendut_carl_api::carl::CarlClient;
     use opendut_types::cluster::{ClusterId, ClusterName};
-    use opendut_types::peer::PeerId;
+    use opendut_types::peer::{PeerId, PeerName};
     use serde::Serialize;
+    use opendut_types::topology::DeviceName;
 
     use crate::DescribeOutputFormat;
 
@@ -212,8 +213,8 @@ pub mod describe {
         name: ClusterName,
         id: ClusterId,
         leader: PeerId,
-        peers: Vec<String>,
-        devices: Vec<String>,
+        peers: Vec<PeerName>,
+        devices: Vec<DeviceName>,
     }
 
     pub async fn execute(carl: &mut CarlClient, id: Uuid, output: DescribeOutputFormat) -> crate::Result<()> {
@@ -242,7 +243,7 @@ pub mod describe {
                 .filter(|peer| {
                     peer.topology.devices.iter().any(|device| cluster_devices.contains(&device.name))
                 })
-                .map(|peer| String::from(peer.name))
+                .map(|peer| peer.name)
                 .collect::<Vec<_>>()
         };
 
@@ -260,9 +261,9 @@ pub mod describe {
                     Cluster Configuration: {}
                       Id: {}
                       Leader: {}
-                      Peers: [{}]
-                      Devices: [{}]
-                "), table.name, table.id, table.leader, table.peers.join(", "), table.devices.join(", "))
+                      Peers: [{:?}]
+                      Devices: [{:?}]
+                "), table.name, table.id, table.leader, table.peers, table.devices)
             }
             DescribeOutputFormat::Json => {
                 serde_json::to_string(&table).unwrap()
diff --git a/opendut-cleo/src/commands/device.rs b/opendut-cleo/src/commands/device.rs
index d92169810..e98b8aea5 100644
--- a/opendut-cleo/src/commands/device.rs
+++ b/opendut-cleo/src/commands/device.rs
@@ -2,18 +2,18 @@ use cli_table::{Table, WithTitle};
 use serde::Serialize;
 
 use opendut_carl_api::carl::CarlClient;
-use opendut_types::topology::{DeviceDescriptor, DeviceId};
+use opendut_types::topology::{DeviceDescription, DeviceDescriptor, DeviceId, DeviceName};
 
 use crate::ListOutputFormat;
 
 #[derive(Table, Serialize)]
 struct DeviceTable {
     #[table(title = "Name")]
-    name: String,
+    name: DeviceName,
     #[table(title = "DeviceID")]
     id: DeviceId,
     #[table(title = "Description")]
-    description: String,
+    description: DeviceDescription,
     #[table(title = "Tags")]
     tags: String,
 }
@@ -34,7 +34,7 @@ pub mod create {
     use uuid::Uuid;
     use opendut_carl_api::carl::CarlClient;
     use opendut_types::peer::{PeerId};
-    use opendut_types::topology::{DeviceDescriptor, DeviceId};
+    use opendut_types::topology::{DeviceDescription, DeviceDescriptor, DeviceId, DeviceName, DeviceTag};
     use opendut_types::util::net::NetworkInterfaceName;
     use crate::{CreateOutputFormat, DescribeOutputFormat};
 
@@ -63,25 +63,41 @@ pub mod create {
 
                 let new_device = DeviceDescriptor {
                     id: device_id,
-                    name,
-                    description: description.unwrap_or_default(),
+                    name: DeviceName::try_from(name)
+                        .map_err(|error| error.to_string())?,
+                    description: description
+                        .map(DeviceDescription::try_from)
+                        .transpose()
+                        .map_err(|error| error.to_string())?,
                     interface,
-                    tags: tags.unwrap_or_default(),
+                    tags: tags
+                        .unwrap_or_default()
+                        .into_iter()
+                        .map(|value| DeviceTag::try_from(value))
+                        .collect::<Result<_, _>>()
+                        .map_err(|error| error.to_string())?,
                 };
                 peer_descriptor.topology.devices.push(new_device);
             }
             Some(device) => {
                 if let Some(name) = name {
-                    device.name = name;
+                    device.name = DeviceName::try_from(name)
+                        .map_err(|error| error.to_string())?;
                 }
                 if let Some(description) = description {
-                    device.description = description; 
+                    device.description = DeviceDescription::try_from(description)
+                        .map_err(|error| error.to_string())
+                        .ok();
                 }
                 if let Some(interface) = interface {
                     device.interface = interface;
                 }
                 if let Some(tags) = tags {
-                    device.tags = tags;
+                    device.tags = tags
+                        .into_iter()
+                        .map(DeviceTag::try_from)
+                        .collect::<Result<_, _>>()
+                        .map_err(|error| error.to_string())?;
                 }
             }
         }
@@ -99,7 +115,7 @@ pub mod describe {
     use uuid::Uuid;
 
     use opendut_carl_api::carl::CarlClient;
-    use opendut_types::topology::DeviceId;
+    use opendut_types::topology::{DeviceDescription, DeviceId};
 
     use crate::DescribeOutputFormat;
 
@@ -120,7 +136,18 @@ pub mod describe {
                       Description: {}
                       Interface: {}
                       Tags: [{}]\
-                "), device.name, device.id, device.description, device.interface, device.tags.join(", "))
+                "),
+                        device.name,
+                        device.id,
+                        device.description
+                            .map(DeviceDescription::from)
+                            .unwrap_or_default(),
+                        device.interface,
+                        device.tags
+                            .iter()
+                            .map(|tag| tag.value())
+                            .collect::<Vec<_>>()
+                            .join(", "))
             }
             DescribeOutputFormat::Json => {
                 serde_json::to_string(&device).unwrap()
@@ -150,11 +177,11 @@ pub mod find {
                 .filter(|device| {
                     criteria.iter().any(|criterion| {
                         let pattern = glob::Pattern::new(criterion).expect("Failed to read glob pattern");
-                        pattern.matches(&device.name.to_lowercase())
+                        pattern.matches(&device.name.value().to_lowercase())
                             || pattern.matches(&device.id.to_string().to_lowercase())
-                            || pattern.matches(&device.description.to_lowercase())
+                            || pattern.matches(&device.description.clone().unwrap().value().to_lowercase())
                             || pattern.matches(&device.interface.to_string().to_lowercase())
-                            || device.tags.iter().any(|tag| pattern.matches(&tag.to_lowercase()))
+                            || device.tags.iter().any(|tag| pattern.matches(&tag.value().to_lowercase()))
                     })
                 })
                 .map(DeviceTable::from)
@@ -216,8 +243,8 @@ impl From<DeviceDescriptor> for DeviceTable {
         DeviceTable {
             name: device.name,
             id: device.id,
-            description: device.description,
-            tags: device.tags.join(", "),
+            description: device.description.unwrap_or_default(),
+            tags: device.tags.iter().map(|tag| tag.value()).collect::<Vec<_>>().join(", "),
         }
     }
 }
diff --git a/opendut-cleo/src/commands/peer.rs b/opendut-cleo/src/commands/peer.rs
index bd804b198..d1a0d83c2 100644
--- a/opendut-cleo/src/commands/peer.rs
+++ b/opendut-cleo/src/commands/peer.rs
@@ -1,4 +1,3 @@
-
 pub mod list {
     use std::fmt::{Display, Formatter};
 
@@ -6,7 +5,7 @@ pub mod list {
     use serde::Serialize;
 
     use opendut_carl_api::carl::CarlClient;
-    use opendut_types::peer::{PeerDescriptor, PeerId, PeerName, PeerLocation};
+    use opendut_types::peer::{PeerDescriptor, PeerId, PeerLocation, PeerName};
 
     use crate::ListOutputFormat;
 
@@ -25,22 +24,28 @@ pub mod list {
     #[derive(Debug, PartialEq, Serialize)]
     enum PeerStatus {
         Connected,
-        Disconnected
+        Disconnected,
     }
 
     impl Display for PeerStatus {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
             match self {
                 PeerStatus::Connected => write!(f, "Connected"),
-                PeerStatus::Disconnected => write!(f, "Disconnected")
+                PeerStatus::Disconnected => write!(f, "Disconnected"),
             }
         }
     }
 
     pub async fn execute(carl: &mut CarlClient, output: ListOutputFormat) -> crate::Result<()> {
-        let connected_peers = carl.broker.list_peers().await
+        let connected_peers = carl
+            .broker
+            .list_peers()
+            .await
             .map_err(|error| format!("Could not list connected peers. {}", error))?;
-        let all_peers = carl.peers.list_peer_descriptors().await
+        let all_peers = carl
+            .peers
+            .list_peer_descriptors()
+            .await
             .map_err(|error| format!("Could not list peers.\n  {}", error))?;
         let peers_table = filter_connected_peers(&all_peers, &connected_peers);
 
@@ -61,53 +66,52 @@ pub mod list {
         Ok(())
     }
 
-    fn filter_connected_peers(all_peers: &[PeerDescriptor], connected_peers: &[PeerId]) -> Vec<PeerTable> {
-        all_peers.iter().map(|peer| {
-            let status = if connected_peers.contains(&peer.id) {
-                PeerStatus::Connected
-            } else {
-                PeerStatus::Disconnected
-            };
-            PeerTable {
-                name: Clone::clone(&peer.name),
-                id: peer.id,
-                location: Clone::clone(&peer.location),
-                status,
-            }
-        }).collect::<Vec<PeerTable>>()
+    fn filter_connected_peers(
+        all_peers: &[PeerDescriptor],
+        connected_peers: &[PeerId],
+    ) -> Vec<PeerTable> {
+        all_peers
+            .iter()
+            .map(|peer| {
+                let status = if connected_peers.contains(&peer.id) {
+                    PeerStatus::Connected
+                } else {
+                    PeerStatus::Disconnected
+                };
+                PeerTable {
+                    name: Clone::clone(&peer.name),
+                    id: peer.id,
+                    location: Clone::clone(&peer.location.clone().unwrap_or_default()),
+                    status,
+                }
+            })
+            .collect::<Vec<PeerTable>>()
     }
 
     #[cfg(test)]
     mod test {
         use googletest::prelude::*;
 
-        use opendut_types::peer::{PeerLocation, PeerDescriptor, PeerId, PeerName};
+        use opendut_types::peer::{PeerDescriptor, PeerId, PeerLocation, PeerName};
 
         use super::*;
 
         #[test]
         fn test() {
-            let all_peers = vec![
-                PeerDescriptor {
-                    id: PeerId::random(),
-                    name: PeerName::try_from("MyPeer").unwrap(),
-                    location: PeerLocation::new("SiFi"),
-                    topology: Default::default(),
-                }
-            ];
-            let connected_peers = vec![
-                all_peers[0].id
-            ];
-            assert_that!(filter_connected_peers(&all_peers, &connected_peers),
-                unordered_elements_are!(
-                    matches_pattern!(
-                        PeerTable {
-                            name: eq(Clone::clone(&all_peers[0].name)),
-                            id: eq(all_peers[0].id),
-                            status: eq(PeerStatus::Connected),
-                        }
-                    )
-                )
+            let all_peers = vec![PeerDescriptor {
+                id: PeerId::random(),
+                name: PeerName::try_from("MyPeer").unwrap(),
+                location: Some(PeerLocation::try_from("SiFi").unwrap()),
+                topology: Default::default(),
+            }];
+            let connected_peers = vec![all_peers[0].id];
+            assert_that!(
+                filter_connected_peers(&all_peers, &connected_peers),
+                unordered_elements_are!(matches_pattern!(PeerTable {
+                    name: eq(Clone::clone(&all_peers[0].name)),
+                    id: eq(all_peers[0].id),
+                    status: eq(PeerStatus::Connected),
+                }))
             );
         }
     }
@@ -122,33 +126,44 @@ pub mod describe {
 
     use crate::DescribeOutputFormat;
 
-    pub async fn execute(carl: &mut CarlClient, peer_id: Uuid, output: DescribeOutputFormat) -> crate::Result<()> {
+    pub async fn execute(
+        carl: &mut CarlClient,
+        peer_id: Uuid,
+        output: DescribeOutputFormat,
+    ) -> crate::Result<()> {
         let peer_id = PeerId::from(peer_id);
 
-        let peer_descriptor = carl.peers.get_peer_descriptor(peer_id).await
-            .map_err(|_| format!("Failed to retrieve peer descriptor for peer <{}>", peer_id))?;
+        let peer_descriptor =
+            carl.peers.get_peer_descriptor(peer_id).await.map_err(|_| {
+                format!("Failed to retrieve peer descriptor for peer <{}>", peer_id)
+            })?;
 
         render_peer_descriptor(peer_descriptor, output);
         Ok(())
     }
 
     pub fn render_peer_descriptor(peer_descriptor: PeerDescriptor, output: DescribeOutputFormat) {
-
-        let peer_devices = peer_descriptor.topology.devices.iter()
-            .map(|device| device.name.clone())
+        let peer_devices = peer_descriptor
+            .topology
+            .devices
+            .iter()
+            .map(|device| device.name.value())
             .collect::<Vec<_>>()
             .join(", ");
         let text = match output {
             DescribeOutputFormat::Text => {
-                format!(indoc!("
+                format!(
+                    indoc!(
+                        "
                     Peer: {}
                       Id: {}
                       Devices: [{}]\
-                "), peer_descriptor.name, peer_descriptor.id, peer_devices)
-            }
-            DescribeOutputFormat::Json => {
-                serde_json::to_string(&peer_descriptor).unwrap()
+                "
+                    ),
+                    peer_descriptor.name, peer_descriptor.id, peer_devices
+                )
             }
+            DescribeOutputFormat::Json => serde_json::to_string(&peer_descriptor).unwrap(),
             DescribeOutputFormat::PrettyJson => {
                 serde_json::to_string_pretty(&peer_descriptor).unwrap()
             }
@@ -158,17 +173,19 @@ pub mod describe {
 }
 
 pub mod generate_peer_setup {
-    use uuid::Uuid;
     use opendut_carl_api::carl::CarlClient;
     use opendut_types::peer::PeerId;
+    use uuid::Uuid;
 
     //TODO: what happens if peer with the ID is already set up?
     pub async fn execute(carl: &mut CarlClient, id: Uuid) -> crate::Result<()> {
         let peer_id = PeerId::from(id);
-        let created_setup = carl.peers.create_peer_setup(peer_id).await
+        let created_setup = carl
+            .peers
+            .create_peer_setup(peer_id)
+            .await
             .map_err(|error| format!("Could not create peer setup.\n  {}", error))?;
 
-
         match created_setup.encode() {
             Ok(setup_key) => {
                 println!("{}", setup_key);
@@ -182,17 +199,18 @@ pub mod generate_peer_setup {
 }
 
 pub mod decode_peer_setup {
-    use opendut_types::peer::PeerSetup;
     use crate::DecodePeerSetupOutputFormat;
+    use opendut_types::peer::PeerSetup;
 
-    pub async fn execute(setup: PeerSetup, output: DecodePeerSetupOutputFormat) -> crate::Result<()> {
+    pub async fn execute(
+        setup: PeerSetup,
+        output: DecodePeerSetupOutputFormat,
+    ) -> crate::Result<()> {
         let text = match output {
             DecodePeerSetupOutputFormat::Text => {
                 format!("{:#?}", setup)
             }
-            DecodePeerSetupOutputFormat::Json => {
-                serde_json::to_string(&setup).unwrap()
-            }
+            DecodePeerSetupOutputFormat::Json => serde_json::to_string(&setup).unwrap(),
             DecodePeerSetupOutputFormat::PrettyJson => {
                 serde_json::to_string_pretty(&setup).unwrap()
             }
@@ -206,49 +224,56 @@ pub mod create {
     use console::Style;
     use uuid::Uuid;
 
+    use crate::CreateOutputFormat;
     use opendut_carl_api::carl::CarlClient;
     use opendut_types::peer::{PeerDescriptor, PeerId, PeerLocation, PeerName};
-    use crate::CreateOutputFormat;
 
-    pub async fn execute(carl: &mut CarlClient, name: String, id: Option<Uuid>, location: Option<String>, output: CreateOutputFormat) -> crate::Result<()> {
+    pub async fn execute(
+        carl: &mut CarlClient,
+        name: String,
+        id: Option<Uuid>,
+        location: Option<String>,
+        output: CreateOutputFormat,
+    ) -> crate::Result<()> {
         let id = PeerId::from(id.unwrap_or_else(Uuid::new_v4));
-        match PeerName::try_from(name) {
-            Ok(name) => {
-                match PeerLocation::try_from(location.unwrap_or_default()) {
-                    Ok(location) => {
-                        let descriptor: PeerDescriptor = PeerDescriptor {
-                            id,
-                            name: Clone::clone(&name),
-                            location,
-                            topology: Default::default()
-                        };
-                        carl.peers.store_peer_descriptor(descriptor.clone()).await
-                            .map_err(|error| format!("Failed to create new peer.\n  {error}"))?;
-                        let bold = Style::new().bold();
-                        match output {
-                            CreateOutputFormat::Text => {
-                                println!("Created the peer '{}' with the ID: <{}>", name, bold.apply_to(id));
-                            }
-                            CreateOutputFormat::Json => {
-                                let json = serde_json::to_string(&descriptor).unwrap();
-                                println!("{}", json);
-                            }
-                            CreateOutputFormat::PrettyJson => {
-                                let json = serde_json::to_string_pretty(&descriptor).unwrap();
-                                println!("{}", json);
-                            }
-                        }
-                        Ok(())
-                    }
-                    Err(error) => {
-                        Err(format!("Could not create peer.\n  {}", error))
-                    }
-                }
+
+        let name = PeerName::try_from(name)
+            .map_err(|error| format!("Could not create peer.\n  {}", error))?;
+
+        let location = location
+            .map(PeerLocation::try_from)
+            .transpose()
+            .map_err(|error| format!("Could not create peer.\n  {}", error))?;
+
+        let descriptor: PeerDescriptor = PeerDescriptor {
+            id,
+            name: Clone::clone(&name),
+            location,
+            topology: Default::default(),
+        };
+        carl.peers
+            .store_peer_descriptor(descriptor.clone())
+            .await
+            .map_err(|error| format!("Failed to create new peer.\n  {error}"))?;
+        let bold = Style::new().bold();
+        match output {
+            CreateOutputFormat::Text => {
+                println!(
+                    "Created the peer '{}' with the ID: <{}>",
+                    name,
+                    bold.apply_to(id)
+                );
+            }
+            CreateOutputFormat::Json => {
+                let json = serde_json::to_string(&descriptor).unwrap();
+                println!("{}", json);
             }
-            Err(error) => {
-                Err(format!("Could not create peer.\n  {}", error))
+            CreateOutputFormat::PrettyJson => {
+                let json = serde_json::to_string_pretty(&descriptor).unwrap();
+                println!("{}", json);
             }
         }
+        Ok(())
     }
 }
 
@@ -260,7 +285,9 @@ pub mod delete {
 
     pub async fn execute(carl: &mut CarlClient, id: Uuid) -> crate::Result<()> {
         let id = PeerId::from(id);
-        carl.peers.delete_peer_descriptor(id).await
+        carl.peers
+            .delete_peer_descriptor(id)
+            .await
             .map_err(|error| format!("Failed to delete peer with the id '{}'.\n  {}", id, error))?;
         println!("Deleted peer with the PeerID: {}", id);
 
diff --git a/opendut-cleo/src/main.rs b/opendut-cleo/src/main.rs
index dc86f2143..72b09e4e5 100644
--- a/opendut-cleo/src/main.rs
+++ b/opendut-cleo/src/main.rs
@@ -143,7 +143,7 @@ enum CreateResource {
         #[arg(long)]
         interface: Option<NetworkInterfaceName>,
         /// Tags of device
-        #[arg(long)]
+        #[arg(long("tag"))]
         tags: Option<Vec<String>>,
     }
 }
diff --git a/opendut-lea/src/clusters/configurator/components/device_selector.rs b/opendut-lea/src/clusters/configurator/components/device_selector.rs
index 11363dc91..caecdcb8e 100644
--- a/opendut-lea/src/clusters/configurator/components/device_selector.rs
+++ b/opendut-lea/src/clusters/configurator/components/device_selector.rs
@@ -43,7 +43,8 @@ pub fn DeviceSelector(cluster_configuration: RwSignal<UserClusterConfiguration>)
             let mut devices = peer.topology.devices;
             let selected_devices = selected_devices();
 
-            devices.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
+            devices.sort_by(|a, b|
+                a.name.value().to_lowercase().cmp(&b.name.value().to_lowercase()));
 
             let devices_per_peer = devices.clone().into_iter()
                 .map(|device| {
@@ -63,9 +64,9 @@ pub fn DeviceSelector(cluster_configuration: RwSignal<UserClusterConfiguration>)
                                 />
                             </td>
                             <td>
-                                {&device.name}
+                                {&device.name.to_string()}
                             </td>
-                            <td>{peer.location.to_string()}</td>
+                            <td>{peer.location.clone().unwrap_or_default().to_string()}</td>
                             <td class="is-narrow">
                                 <IconButton
                                     icon=FontAwesomeIcon::Check
@@ -148,13 +149,13 @@ pub fn DeviceInfo(device: DeviceDescriptor, peer_id: PeerId) -> impl IntoView {
             <div class="field">
                 <label class="label">Tags</label>
                 <div class="control">
-                    <p>{device.tags}</p>
+                    <p>{device.tags.iter().map(|tag| tag.value()).collect::<Vec<_>>().join("* ")}</p>
                 </div>
             </div>
             <div class="field">
                 <label class="label">Description</label>
                 <div class="control">
-                    <p>{device.description}</p>
+                    <p>{device.description.unwrap_or_default().to_string()}</p>
                 </div>
             </div>
         </td>
diff --git a/opendut-lea/src/clusters/configurator/components/leader_selector.rs b/opendut-lea/src/clusters/configurator/components/leader_selector.rs
index 50592e049..14582df85 100644
--- a/opendut-lea/src/clusters/configurator/components/leader_selector.rs
+++ b/opendut-lea/src/clusters/configurator/components/leader_selector.rs
@@ -61,7 +61,7 @@ pub fn LeaderSelector(cluster_configuration: RwSignal<UserClusterConfiguration>)
                             {&peer.id.to_string()}
                         </td>
                         <td>
-                            {&peer.location.to_string()}
+                            {&peer.location.unwrap_or_default().to_string()}
                         </td>
                         <td class="is-narrow" style="text-align: center">
                             <div class="control">
diff --git a/opendut-lea/src/components/inputs/mod.rs b/opendut-lea/src/components/inputs/mod.rs
index f41408e4f..f4c525f71 100644
--- a/opendut-lea/src/components/inputs/mod.rs
+++ b/opendut-lea/src/components/inputs/mod.rs
@@ -2,6 +2,7 @@ use crate::util::Ior;
 
 pub mod readonly_input;
 pub mod user_input;
+pub mod user_textarea;
 
 pub type UserInputError = String;
 pub type UserInputValue = Ior<UserInputError, String>;
diff --git a/opendut-lea/src/components/inputs/user_textarea.rs b/opendut-lea/src/components/inputs/user_textarea.rs
new file mode 100644
index 000000000..1bd0804d2
--- /dev/null
+++ b/opendut-lea/src/components/inputs/user_textarea.rs
@@ -0,0 +1,58 @@
+use leptos::*;
+use crate::components::inputs::{UserInputValidator, UserInputValue};
+
+use crate::util::NON_BREAKING_SPACE;
+
+#[component]
+pub fn UserTextarea<A>(
+    getter: Signal<UserInputValue>,
+    setter: SignalSetter<UserInputValue>,
+    #[prop(optional)] validator: Option<A>,
+    #[prop(into)] label: MaybeSignal<String>,
+    #[prop(into)] placeholder: MaybeSignal<String>,
+) -> impl IntoView
+where A: UserInputValidator + 'static {
+
+    let value_text = move || {
+        getter.with(|input| match input {
+            UserInputValue::Left(_) => String::new(),
+            UserInputValue::Right(value) => value.to_owned(),
+            UserInputValue::Both(_, value) => value.to_owned(),
+        })
+    };
+
+    let help_text = move || {
+        getter.with(|input| match input {
+            UserInputValue::Right(_) => String::from(NON_BREAKING_SPACE),
+            UserInputValue::Left(error) => error.to_owned(),
+            UserInputValue::Both(error, _) => error.to_owned(),
+        })
+    };
+
+    let aria_label = Clone::clone(&label);
+
+    view! {
+        <div class="field">
+            <label class="label">{ label }</label>
+            <div class="control">
+                <textarea
+                    class="textarea"
+                    aria-label=move || aria_label.get()
+                    placeholder=move || placeholder.get()
+                    prop:value={ value_text }
+                    on:input=move |ev| {
+                        if let Some(validator) = &validator {
+                            let validated_value = validator.validate(event_target_value(&ev));
+                            setter.set(validated_value);
+                        }
+                        else {
+                            let target_value = event_target_value(&ev);
+                            setter.set(UserInputValue::Right(target_value));
+                        }
+                    }
+                />
+            </div>
+            <p class="help has-text-danger">{ help_text }</p>
+        </div>
+    }
+}
diff --git a/opendut-lea/src/components/mod.rs b/opendut-lea/src/components/mod.rs
index 3975de330..45bee75b6 100644
--- a/opendut-lea/src/components/mod.rs
+++ b/opendut-lea/src/components/mod.rs
@@ -6,6 +6,7 @@ pub use initialized::Initialized;
 pub use inputs::{UserInputError, UserInputValue};
 pub use inputs::readonly_input::ReadOnlyInput;
 pub use inputs::user_input::UserInput;
+pub use inputs::user_textarea::UserTextarea;
 pub use page::BasePageContainer;
 pub use toast::{use_toaster, Toaster, Toast, ToastKind, ToastContent};
 pub use util::ButtonStateSignalProvider;
diff --git a/opendut-lea/src/peers/configurator/mod.rs b/opendut-lea/src/peers/configurator/mod.rs
index 858c05f9e..1e8937cad 100644
--- a/opendut-lea/src/peers/configurator/mod.rs
+++ b/opendut-lea/src/peers/configurator/mod.rs
@@ -62,13 +62,13 @@ pub fn PeerConfigurator() -> impl IntoView {
                         peer_configuration.update(|user_configuration| {
                             user_configuration.name = UserInputValue::Right(configuration.name.value());
                             user_configuration.is_new = false;
-                            user_configuration.location = UserInputValue::Right(configuration.location.value());
+                            user_configuration.location = UserInputValue::Right(configuration.location.unwrap_or_default().value());
                             user_configuration.devices = configuration.topology.devices.into_iter().map(|device| {
                                 create_rw_signal(UserDeviceConfiguration {
                                     id: device.id,
-                                    name: UserInputValue::Right(device.name),
+                                    name: UserInputValue::Right(device.name.to_string()),
                                     interface: UserInputValue::Right(device.interface.name()),
-                                    description: device.description,
+                                    description: UserInputValue::Right(device.description.unwrap_or_default().to_string()),
                                     is_collapsed: true
                                 })
                             }).collect::<Vec<_>>();
diff --git a/opendut-lea/src/peers/configurator/tabs/devices/device_panel.rs b/opendut-lea/src/peers/configurator/tabs/devices/device_panel.rs
index a79e61f11..8d651769f 100644
--- a/opendut-lea/src/peers/configurator/tabs/devices/device_panel.rs
+++ b/opendut-lea/src/peers/configurator/tabs/devices/device_panel.rs
@@ -1,8 +1,9 @@
-use leptos::{component, create_read_slice, create_slice, event_target_value, IntoView, MaybeSignal, RwSignal, SignalGet, SignalGetUntracked, view};
-use opendut_types::topology::DeviceId;
+use leptos::{component, create_read_slice, create_slice, IntoView, MaybeSignal, RwSignal, SignalGet, SignalGetUntracked, view};
+
+use opendut_types::topology::{DeviceDescription, DeviceId};
 use opendut_types::util::net::NetworkInterfaceName;
 
-use crate::components::{ButtonColor, ButtonSize, ButtonState, ConfirmationButton, FontAwesomeIcon, IconButton, ReadOnlyInput, Toggled, UserInput, UserInputValue};
+use crate::components::{ButtonColor, ButtonSize, ButtonState, ConfirmationButton, FontAwesomeIcon, IconButton, ReadOnlyInput, Toggled, UserInput, UserInputValue, UserTextarea};
 use crate::peers::configurator::types::{EMPTY_DEVICE_NAME_ERROR_MESSAGE, UserDeviceConfiguration};
 
 #[component]
@@ -182,20 +183,25 @@ fn DeviceDescriptionInput(
         }
     );
 
+    let validator = |input: String| {
+        match DeviceDescription::try_from(Clone::clone(&input)) {
+            Err(error) => {
+                UserInputValue::Both(error.to_string(), input)
+            }
+            Ok(_) => {
+                UserInputValue::Right(input)
+            }
+        }
+    };
+
     view! {
-        <div class="field">
-            <label class="label">"Description"</label>
-            <div class="control">
-                <textarea
-                    class="textarea"
-                    aria-label="Description"
-                    prop:value=getter
-                    on:input=move |event| {
-                        setter.set(event_target_value(&event));
-                    }
-                />
-            </div>
-        </div>
+        <UserTextarea
+            getter=getter
+            setter=setter
+            label="Description"
+            placeholder="Description"
+            validator
+        />
     }
 }
 
diff --git a/opendut-lea/src/peers/configurator/tabs/devices/mod.rs b/opendut-lea/src/peers/configurator/tabs/devices/mod.rs
index 8609823b6..007517b6f 100644
--- a/opendut-lea/src/peers/configurator/tabs/devices/mod.rs
+++ b/opendut-lea/src/peers/configurator/tabs/devices/mod.rs
@@ -67,7 +67,7 @@ fn DevicesTable(peer_configuration: RwSignal<UserPeerConfiguration>) -> impl Int
                                 UserDeviceConfiguration {
                                     id: device_id,
                                     name: UserInputValue::Left(String::from(EMPTY_DEVICE_NAME_ERROR_MESSAGE)),
-                                    description: String::new(),
+                                    description: UserInputValue::Right(String::from("")),
                                     interface: UserInputValue::Left(String::from(EMPTY_DEVICE_INTERFACE_ERROR_MESSAGE)),
                                     is_collapsed: false
                                 }
diff --git a/opendut-lea/src/peers/configurator/types.rs b/opendut-lea/src/peers/configurator/types.rs
index 37b1531ae..f02c8cb45 100644
--- a/opendut-lea/src/peers/configurator/types.rs
+++ b/opendut-lea/src/peers/configurator/types.rs
@@ -1,7 +1,7 @@
 use leptos::{RwSignal, SignalGetUntracked};
 
 use opendut_types::peer::{PeerDescriptor, PeerId, PeerLocation, PeerName};
-use opendut_types::topology::{DeviceDescriptor, DeviceId, Topology};
+use opendut_types::topology::{DeviceDescription, DeviceDescriptor, DeviceId, DeviceName, Topology};
 use opendut_types::util::net::NetworkInterfaceName;
 
 use crate::components::UserInputValue;
@@ -25,6 +25,8 @@ pub enum DeviceMisconfigurationError {
     InvalidDeviceLocation,
     #[error("Invalid device interface")]
     InvalidDeviceInterface,
+    #[error("Invalid device description")]
+    InvalidDeviceDescription,
 }
 
 #[derive(Clone, Debug)]
@@ -40,7 +42,7 @@ pub struct UserPeerConfiguration {
 pub struct UserDeviceConfiguration {
     pub id: DeviceId,
     pub name: UserInputValue,
-    pub description: String,
+    pub description: UserInputValue,
     pub interface: UserInputValue,
     pub is_collapsed: bool,
 }
@@ -74,7 +76,7 @@ impl TryFrom<UserPeerConfiguration> for PeerDescriptor {
         Ok(PeerDescriptor {
             id: configuration.id,
             name,
-            location,
+            location: Some(location),
             topology: Topology::new(devices),
         })
     }
@@ -86,7 +88,11 @@ impl TryFrom<UserDeviceConfiguration> for DeviceDescriptor {
     fn try_from(configuration: UserDeviceConfiguration) -> Result<Self, Self::Error> {
         let name = configuration
             .name
-            .right_ok_or(DeviceMisconfigurationError::InvalidDeviceName)?;
+            .right_ok_or(DeviceMisconfigurationError::InvalidDeviceName)
+            .and_then(|name| {
+                DeviceName::try_from(name)
+                    .map_err(|_| DeviceMisconfigurationError::InvalidDeviceName)
+            })?;
         let interface = configuration
             .interface
             .right_ok_or(DeviceMisconfigurationError::InvalidDeviceInterface)
@@ -94,10 +100,17 @@ impl TryFrom<UserDeviceConfiguration> for DeviceDescriptor {
                 NetworkInterfaceName::try_from(interface_name)
                     .map_err(|_| DeviceMisconfigurationError::InvalidDeviceInterface)
             })?;
+        let description = configuration
+            .description
+            .right_ok_or(DeviceMisconfigurationError::InvalidDeviceDescription)
+            .and_then(|description| {
+                DeviceDescription::try_from(description)
+                    .map_err(|_| DeviceMisconfigurationError::InvalidDeviceDescription)
+            })?;
         Ok(DeviceDescriptor {
             id: configuration.id,
             name,
-            description: configuration.description,
+            description: Some(description),
             interface,
             tags: vec![],
         })
diff --git a/opendut-types/proto/opendut/types/topology/device.proto b/opendut-types/proto/opendut/types/topology/device.proto
index d814c30f7..670df446d 100644
--- a/opendut-types/proto/opendut/types/topology/device.proto
+++ b/opendut-types/proto/opendut/types/topology/device.proto
@@ -11,8 +11,20 @@ message DeviceId {
 
 message DeviceDescriptor {
   opendut.types.topology.DeviceId id = 1;
-  string name = 2;
-  string description = 3;
+  opendut.types.topology.DeviceName name = 2;
+  opendut.types.topology.DeviceDescription description = 3;
   opendut.types.util.NetworkInterfaceName interface = 4;
-  repeated string tags = 5;
+  repeated opendut.types.topology.DeviceTag tags = 5;
+}
+
+message DeviceName {
+  string value = 1;
+}
+
+message DeviceDescription {
+  string value = 1;
+}
+
+message DeviceTag {
+  string value = 1;
 }
diff --git a/opendut-types/src/cluster/mod.rs b/opendut-types/src/cluster/mod.rs
index 802480abb..a3c2174ba 100644
--- a/opendut-types/src/cluster/mod.rs
+++ b/opendut-types/src/cluster/mod.rs
@@ -112,7 +112,7 @@ impl TryFrom<String> for ClusterName {
                 actual: length,
             })
         }
-        else if crate::util::valid_start_and_end_of_a_name( & value).not()
+        else if crate::util::invalid_start_and_end_of_a_name( & value)
             || value.chars().any(|c| crate::util::valid_characters_in_name(&c).not()) {
                 Err(IllegalClusterName::InvalidCharacter {
                     value
diff --git a/opendut-types/src/peer/mod.rs b/opendut-types/src/peer/mod.rs
index a91378d9e..89a534a47 100644
--- a/opendut-types/src/peer/mod.rs
+++ b/opendut-types/src/peer/mod.rs
@@ -2,8 +2,8 @@ use std::fmt;
 use std::io::{Read, Write};
 use std::ops::Not;
 
-use base64::Engine;
 use base64::prelude::BASE64_URL_SAFE;
+use base64::Engine;
 use serde::{Deserialize, Serialize};
 use url::Url;
 use uuid::Uuid;
@@ -18,7 +18,6 @@ pub mod state;
 pub struct PeerId(pub Uuid);
 
 impl PeerId {
-
     pub const NIL: Self = Self(Uuid::from_bytes([0; 16]));
 
     pub fn random() -> Self {
@@ -45,18 +44,16 @@ pub struct IllegalPeerId {
 }
 
 impl TryFrom<&str> for PeerId {
-
     type Error = IllegalPeerId;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
-        Uuid::parse_str(value)
-            .map(Self)
-            .map_err(|_| IllegalPeerId { value: String::from(value) })
+        Uuid::parse_str(value).map(Self).map_err(|_| IllegalPeerId {
+            value: String::from(value),
+        })
     }
 }
 
 impl TryFrom<String> for PeerId {
-
     type Error = IllegalPeerId;
 
     fn try_from(value: String) -> Result<Self, Self::Error> {
@@ -70,12 +67,10 @@ impl fmt::Display for PeerId {
     }
 }
 
-
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 pub struct PeerName(pub(crate) String);
 
 impl PeerName {
-
     pub const MIN_LENGTH: usize = 4;
     pub const MAX_LENGTH: usize = 64;
 
@@ -86,10 +81,22 @@ impl PeerName {
 
 #[derive(thiserror::Error, Clone, Debug)]
 pub enum IllegalPeerName {
-    #[error("Peer name '{value}' is too short. Expected at least {expected} characters, got {actual}.")]
-    TooShort { value: String, expected: usize, actual: usize },
-    #[error("Peer name '{value}' is too long. Expected at most {expected} characters, got {actual}.")]
-    TooLong { value: String, expected: usize, actual: usize },
+    #[error(
+        "Peer name '{value}' is too short. Expected at least {expected} characters, got {actual}."
+    )]
+    TooShort {
+        value: String,
+        expected: usize,
+        actual: usize,
+    },
+    #[error(
+        "Peer name '{value}' is too long. Expected at most {expected} characters, got {actual}."
+    )]
+    TooLong {
+        value: String,
+        expected: usize,
+        actual: usize,
+    },
     #[error("Peer name '{value}' contains invalid characters.")]
     InvalidCharacter { value: String },
 }
@@ -101,7 +108,6 @@ impl From<PeerName> for String {
 }
 
 impl TryFrom<String> for PeerName {
-
     type Error = IllegalPeerName;
 
     fn try_from(value: String) -> Result<Self, Self::Error> {
@@ -112,27 +118,25 @@ impl TryFrom<String> for PeerName {
                 expected: Self::MIN_LENGTH,
                 actual: length,
             })
-        }
-        else if length > Self::MAX_LENGTH {
+        } else if length > Self::MAX_LENGTH {
             Err(IllegalPeerName::TooLong {
                 value,
                 expected: Self::MAX_LENGTH,
                 actual: length,
             })
-        } else if crate::util::valid_start_and_end_of_a_name(&value).not()
-            || value.chars().any(|c| crate::util::valid_characters_in_name(&c).not()) {
-                Err(IllegalPeerName::InvalidCharacter {
-                    value
-                })
-        }
-        else {
+        } else if crate::util::invalid_start_and_end_of_a_name(&value)
+            || value
+                .chars()
+                .any(|c| crate::util::valid_characters_in_name(&c).not())
+        {
+            Err(IllegalPeerName::InvalidCharacter { value })
+        } else {
             Ok(Self(value))
         }
     }
 }
 
 impl TryFrom<&str> for PeerName {
-
     type Error = IllegalPeerName;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
@@ -150,21 +154,21 @@ impl fmt::Display for PeerName {
 pub struct PeerLocation(pub(crate) String);
 
 impl PeerLocation {
-
-    pub const MIN_LENGTH: usize = 0;
     pub const MAX_LENGTH: usize = 64;
 
     pub fn value(self) -> String {
         self.0
     }
-
-    pub fn new(location: &str) -> PeerLocation { Self { 0: String::from(location) } }
 }
 
 #[derive(thiserror::Error, Clone, Debug)]
 pub enum IllegalLocation {
     #[error("Peer location '{value}' is too long. Expected at most {expected} characters, got {actual}.")]
-    TooLong { value: String, expected: usize, actual: usize },
+    TooLong {
+        value: String,
+        expected: usize,
+        actual: usize,
+    },
     #[error("Peer location '{value}' contains invalid characters.")]
     InvalidCharacter { value: String },
     #[error("Peer location '{value}' contains invalid start or end characters.")]
@@ -178,7 +182,6 @@ impl From<PeerLocation> for String {
 }
 
 impl TryFrom<String> for PeerLocation {
-
     type Error = IllegalLocation;
 
     fn try_from(value: String) -> Result<Self, Self::Error> {
@@ -189,23 +192,20 @@ impl TryFrom<String> for PeerLocation {
                 expected: Self::MAX_LENGTH,
                 actual: length,
             })
-        } else if crate::util::valid_start_and_end_of_location(&value).not() {
-            Err(IllegalLocation::InvalidStartEndCharacter {
-                value
-            })
-        } else if value.chars().any(|c| crate::util::valid_characters_in_location(&c).not()) {
-            Err(IllegalLocation::InvalidCharacter {
-                value
-            })
-        }
-        else {
+        } else if crate::util::invalid_start_and_end_of_location(&value) {
+            Err(IllegalLocation::InvalidStartEndCharacter { value })
+        } else if value
+            .chars()
+            .any(|c| crate::util::valid_characters_in_location(&c).not())
+        {
+            Err(IllegalLocation::InvalidCharacter { value })
+        } else {
             Ok(Self(value))
         }
     }
 }
 
 impl TryFrom<&str> for PeerLocation {
-
     type Error = IllegalLocation;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
@@ -223,7 +223,7 @@ impl fmt::Display for PeerLocation {
 pub struct PeerDescriptor {
     pub id: PeerId,
     pub name: PeerName,
-    pub location: PeerLocation,
+    pub location: Option<PeerLocation>,
     pub topology: Topology,
 }
 
@@ -235,17 +235,18 @@ pub struct PeerSetup {
 }
 
 impl PeerSetup {
-
     pub fn encode(&self) -> Result<String, PeerSetupEncodeError> {
-
-        let json = serde_json::to_string(self)
-            .map_err(|cause| PeerSetupEncodeError { details: format!("Serialization failed due to: {}", cause) })?;
+        let json = serde_json::to_string(self).map_err(|cause| PeerSetupEncodeError {
+            details: format!("Serialization failed due to: {}", cause),
+        })?;
 
         let compressed = {
             let mut buffer = Vec::new();
             brotli::CompressorReader::new(json.as_bytes(), 4096, 11, 20)
                 .read_to_end(&mut buffer)
-                .map_err(|cause| PeerSetupEncodeError { details: format!("Compression failed due to: {}", cause) } )?;
+                .map_err(|cause| PeerSetupEncodeError {
+                    details: format!("Compression failed due to: {}", cause),
+                })?;
             buffer
         };
 
@@ -255,20 +256,25 @@ impl PeerSetup {
     }
 
     pub fn decode(encoded: &str) -> Result<Self, PeerSetupDecodeError> {
-
-        let compressed = BASE64_URL_SAFE.decode(encoded.as_bytes())
-            .map_err(|cause| PeerSetupDecodeError { details: format!("Base64 decoding failed due to: {}", cause) } )?;
+        let compressed = BASE64_URL_SAFE
+            .decode(encoded.as_bytes())
+            .map_err(|cause| PeerSetupDecodeError {
+                details: format!("Base64 decoding failed due to: {}", cause),
+            })?;
 
         let json = {
             let mut buffer = Vec::new();
             brotli::DecompressorWriter::new(&mut buffer, 4096)
                 .write_all(compressed.as_slice())
-                .map_err(|cause| PeerSetupDecodeError { details: format!("Decompression failed due to: {}", cause) } )?;
+                .map_err(|cause| PeerSetupDecodeError {
+                    details: format!("Decompression failed due to: {}", cause),
+                })?;
             buffer
         };
 
-        let decoded = serde_json::from_slice(&json)
-            .map_err(|cause| PeerSetupDecodeError { details: format!("Deserialization failed due to: {}", cause) })?;
+        let decoded = serde_json::from_slice(&json).map_err(|cause| PeerSetupDecodeError {
+            details: format!("Deserialization failed due to: {}", cause),
+        })?;
 
         Ok(decoded)
     }
@@ -276,11 +282,15 @@ impl PeerSetup {
 
 #[derive(thiserror::Error, Debug)]
 #[error("PeerSetup could not be encoded. {details}")]
-pub struct PeerSetupEncodeError { details: String }
+pub struct PeerSetupEncodeError {
+    details: String,
+}
 
 #[derive(thiserror::Error, Debug)]
 #[error("PeerSetup could not be decoded. {details}")]
-pub struct PeerSetupDecodeError { details: String }
+pub struct PeerSetupDecodeError {
+    details: String,
+}
 
 #[cfg(test)]
 #[allow(non_snake_case)]
@@ -294,14 +304,13 @@ mod tests {
 
     #[test]
     fn A_PeerSetup_should_be_encodable() -> Result<()> {
-
         let setup = PeerSetup {
             id: PeerId::try_from("01bf3f8c-cc7c-4114-9520-91bce71dcead").unwrap(),
             carl: Url::parse("https://carl.opendut.local")?,
             vpn: VpnPeerConfig::Netbird {
                 management_url: Url::parse("https://netbird.opendut.local/api")?,
                 setup_key: SetupKey::from(Uuid::parse_str("d79c202f-bbbf-4997-844e-678f27606e1c")?),
-            }
+            },
         };
 
         let encoded = setup.encode()?;
@@ -315,21 +324,24 @@ mod tests {
 
     #[test]
     fn A_PeerName_should_contain_valid_characters() -> Result<()> {
-        let peer_name = PeerName::try_from("asd123".to_string()).expect("Failed to create peer name");
+        let peer_name =
+            PeerName::try_from("asd123".to_string()).expect("Failed to create peer name");
         assert_eq!(peer_name.0, "asd123");
         Ok(())
     }
 
     #[test]
     fn A_PeerName_may_contain_a_hyphen() -> Result<()> {
-        let peer_name = PeerName::try_from("asd-123".to_string()).expect("Failed to create peer name");
+        let peer_name =
+            PeerName::try_from("asd-123".to_string()).expect("Failed to create peer name");
         assert_eq!(peer_name.0, "asd-123");
         Ok(())
     }
 
     #[test]
     fn A_PeerName_may_contain_an_underscore() -> Result<()> {
-        let peer_name = PeerName::try_from("asd-123".to_string()).expect("Failed to create peer name");
+        let peer_name =
+            PeerName::try_from("asd-123".to_string()).expect("Failed to create peer name");
         assert_eq!(peer_name.0, "asd-123");
         Ok(())
     }
diff --git a/opendut-types/src/proto/peer.rs b/opendut-types/src/proto/peer.rs
index ae1f8d51f..f44abad33 100644
--- a/opendut-types/src/proto/peer.rs
+++ b/opendut-types/src/proto/peer.rs
@@ -60,6 +60,14 @@ impl From<crate::peer::PeerLocation> for PeerLocation {
     }
 }
 
+impl From<&str> for PeerLocation {
+    fn from(value: &str) -> Self {
+        Self {
+            value: String::from(value)
+        }
+    }
+}
+
 impl TryFrom<PeerLocation> for crate::peer::PeerLocation {
     type Error = ConversionError;
 
@@ -76,7 +84,7 @@ impl From<crate::peer::PeerDescriptor> for PeerDescriptor {
         Self {
             id: Some(value.id.into()),
             name: Some(value.name.into()),
-            location: Some(value.location.into()),
+            location: Some(value.location.unwrap_or_default().into()),
             topology: Some(value.topology.into()),
         }
     }
@@ -97,8 +105,8 @@ impl TryFrom<PeerDescriptor> for crate::peer::PeerDescriptor {
             .try_into()?;
 
         let location = value.location
-            .ok_or(ErrorBuilder::new("Location not set"))?
-            .try_into()?;
+            .map(crate::peer::PeerLocation::try_from)
+            .transpose()?;
 
         let topology = value.topology
             .ok_or(ErrorBuilder::new("Topology not set"))?
@@ -310,6 +318,38 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn A_PeerLocation_should_be_convertable_to_its_proto_and_vice_versa() -> Result<()> {
+
+        let peer_location = "Ulm";
+
+        let native = crate::peer::PeerLocation::try_from(peer_location).unwrap();
+        let proto = PeerLocation::from(peer_location);
+
+        assert_that!(
+            crate::peer::PeerLocation::try_from(Clone::clone(&proto)),
+            ok(eq(native.clone()))
+        );
+
+        assert_that!(PeerLocation::from(native), eq(proto));
+
+        Ok(())
+    }
+
+    #[test]
+    fn A_invalid_PeerLocation_should_not_be_convertable_to_its_proto_and_vice_versa() -> Result<()> {
+
+        let peer_location_with_invalid_start_char = "-Ulm";
+        let peer_location_with_invalid_characters = "Ul/&$#@m";
+        let peer_location_is_empty = "";
+
+        assert!(crate::peer::PeerLocation::try_from(peer_location_with_invalid_start_char).is_err());
+        assert!(crate::peer::PeerLocation::try_from(peer_location_with_invalid_characters).is_err());
+        assert!(crate::peer::PeerLocation::try_from(peer_location_is_empty).is_ok());
+
+        Ok(())
+    }
+
     #[test]
     fn A_PeerState_should_be_convertable_to_its_proto_and_vice_versa() -> Result<()> {
 
diff --git a/opendut-types/src/proto/topology.rs b/opendut-types/src/proto/topology.rs
index d87e84cb5..c9bb612d7 100644
--- a/opendut-types/src/proto/topology.rs
+++ b/opendut-types/src/proto/topology.rs
@@ -5,7 +5,7 @@ include!(concat!(env!("OUT_DIR"), "/opendut.types.topology.rs"));
 impl From<crate::topology::DeviceId> for DeviceId {
     fn from(value: crate::topology::DeviceId) -> Self {
         Self {
-            uuid: Some(value.0.into())
+            uuid: Some(value.0.into()),
         }
     }
 }
@@ -16,7 +16,8 @@ impl TryFrom<DeviceId> for crate::topology::DeviceId {
     fn try_from(value: DeviceId) -> Result<Self, Self::Error> {
         type ErrorBuilder = ConversionErrorBuilder<DeviceId, crate::topology::DeviceId>;
 
-        value.uuid
+        value
+            .uuid
             .ok_or(ErrorBuilder::new("Uuid not set"))
             .map(|uuid| Self(uuid.into()))
     }
@@ -25,7 +26,7 @@ impl TryFrom<DeviceId> for crate::topology::DeviceId {
 impl From<uuid::Uuid> for DeviceId {
     fn from(value: uuid::Uuid) -> Self {
         Self {
-            uuid: Some(value.into())
+            uuid: Some(value.into()),
         }
     }
 }
@@ -33,7 +34,8 @@ impl From<uuid::Uuid> for DeviceId {
 impl From<crate::topology::Topology> for Topology {
     fn from(value: crate::topology::Topology) -> Self {
         Self {
-            device_descriptors: value.devices
+            device_descriptors: value
+                .devices
                 .into_iter()
                 .map(DeviceDescriptor::from)
                 .collect(),
@@ -45,13 +47,70 @@ impl TryFrom<Topology> for crate::topology::Topology {
     type Error = ConversionError;
 
     fn try_from(value: Topology) -> Result<Self, Self::Error> {
-        value.device_descriptors
+        value
+            .device_descriptors
             .into_iter()
             .map(DeviceDescriptor::try_into)
             .collect::<Result<_, _>>()
-            .map(|devices| Self {
-                devices
-            })
+            .map(|devices| Self { devices })
+    }
+}
+
+impl From<crate::topology::DeviceName> for DeviceName {
+    fn from(value: crate::topology::DeviceName) -> Self {
+        Self {
+            value: String::from(value.value()),
+        }
+    }
+}
+
+impl TryFrom<DeviceName> for crate::topology::DeviceName {
+    type Error = ConversionError;
+
+    fn try_from(value: DeviceName) -> Result<Self, Self::Error> {
+        type ErrorBuilder = ConversionErrorBuilder<DeviceName, crate::topology::DeviceName>;
+
+        crate::topology::DeviceName::try_from(value.value)
+            .map_err(|cause| ErrorBuilder::new(cause.to_string()))
+    }
+}
+
+impl TryFrom<DeviceDescription> for crate::topology::DeviceDescription {
+    type Error = ConversionError;
+
+    fn try_from(value: DeviceDescription) -> Result<Self, Self::Error> {
+        type ErrorBuilder =
+            ConversionErrorBuilder<DeviceDescription, crate::topology::DeviceDescription>;
+
+        crate::topology::DeviceDescription::try_from(value.value)
+            .map_err(|cause| ErrorBuilder::new(cause.to_string()))
+    }
+}
+
+impl TryFrom<DeviceTag> for crate::topology::DeviceTag {
+    type Error = ConversionError;
+
+    fn try_from(value: DeviceTag) -> Result<Self, Self::Error> {
+        type ErrorBuilder = ConversionErrorBuilder<DeviceTag, crate::topology::DeviceTag>;
+
+        crate::topology::DeviceTag::try_from(value.value)
+            .map_err(|cause| ErrorBuilder::new(cause.to_string()))
+    }
+}
+
+impl From<Option<crate::topology::DeviceDescription>> for DeviceDescription {
+    fn from(value: Option<crate::topology::DeviceDescription>) -> Self {
+        Self {
+            value: String::from(value.unwrap_or_default().value()),
+        }
+    }
+}
+
+impl From<crate::topology::DeviceTag> for DeviceTag {
+    fn from(value: crate::topology::DeviceTag) -> Self {
+        Self {
+            value: String::from(value.value()),
+        }
     }
 }
 
@@ -59,10 +118,10 @@ impl From<crate::topology::DeviceDescriptor> for DeviceDescriptor {
     fn from(value: crate::topology::DeviceDescriptor) -> Self {
         Self {
             id: Some(value.id.into()),
-            name: value.name,
-            description: value.description,
+            name: Some(value.name.into()),
+            description: Some(value.description.into()),
             interface: Some(value.interface.into()),
-            tags: value.tags,
+            tags: value.tags.into_iter().map(|value| value.into()).collect(),
         }
     }
 }
@@ -71,21 +130,35 @@ impl TryFrom<DeviceDescriptor> for crate::topology::DeviceDescriptor {
     type Error = ConversionError;
 
     fn try_from(value: DeviceDescriptor) -> Result<Self, Self::Error> {
-        type ErrorBuilder = ConversionErrorBuilder<DeviceDescriptor, crate::topology::DeviceDescriptor>;
+        type ErrorBuilder =
+            ConversionErrorBuilder<DeviceDescriptor, crate::topology::DeviceDescriptor>;
 
-        let device_id: crate::topology::DeviceId = value.id
+        let device_id: crate::topology::DeviceId = value
+            .id
             .ok_or(ErrorBuilder::new("Id not set"))?
             .try_into()?;
-        let interface: crate::util::net::NetworkInterfaceName = value.interface
+        let device_name: crate::topology::DeviceName = value
+            .name
+            .ok_or(ErrorBuilder::new("Name not set"))?
+            .try_into()?;
+        let device_description: Option<crate::topology::DeviceDescription> =
+            value.description.map(TryFrom::try_from).transpose()?;
+        let interface: crate::util::net::NetworkInterfaceName = value
+            .interface
             .ok_or(ErrorBuilder::new("Interface not set"))?
             .try_into()?;
+        let device_tags: Vec<crate::topology::DeviceTag> = value
+            .tags
+            .into_iter()
+            .map(TryFrom::try_from)
+            .collect::<Result<_, _>>()?;
 
         Ok(Self {
             id: device_id,
-            name: value.name,
-            description: value.description,
+            name: device_name,
+            description: device_description,
             interface,
-            tags: value.tags,
+            tags: device_tags,
         })
     }
 }
@@ -93,15 +166,15 @@ impl TryFrom<DeviceDescriptor> for crate::topology::DeviceDescriptor {
 #[cfg(test)]
 #[allow(non_snake_case)]
 mod tests {
+    use crate::proto::util::NetworkInterfaceName;
+    use crate::topology::{DeviceDescription, DeviceName, DeviceTag};
     use googletest::prelude::*;
     use uuid::Uuid;
-    use crate::proto::util::NetworkInterfaceName;
 
     use super::*;
 
     #[test]
     fn A_Topology_should_be_convertable_to_its_proto_and_vice_versa() -> Result<()> {
-
         let device_id_1 = Uuid::new_v4();
         let device_id_2 = Uuid::new_v4();
 
@@ -109,18 +182,18 @@ mod tests {
             devices: vec![
                 crate::topology::DeviceDescriptor {
                     id: Clone::clone(&device_id_1).into(),
-                    name: String::from("device-1"),
-                    description: String::from("Some device"),
-                    interface: crate::util::net::NetworkInterfaceName::try_from("tap0").unwrap(),
-                    tags: vec![String::from("tag-1"), String::from("tag-2")],
+                    name: DeviceName::try_from("device-1")?,
+                    description: DeviceDescription::try_from("Some device").ok(),
+                    interface: crate::util::net::NetworkInterfaceName::try_from("tap0")?,
+                    tags: vec![DeviceTag::try_from("tag-1")?, DeviceTag::try_from("tag-2")?],
                 },
                 crate::topology::DeviceDescriptor {
                     id: Clone::clone(&device_id_2).into(),
-                    name: String::from("device-2"),
-                    description: String::from("Some other device"),
-                    interface: crate::util::net::NetworkInterfaceName::try_from("tap1").unwrap(),
-                    tags: vec![String::from("tag-2")],
-                }
+                    name: DeviceName::try_from("device-2")?,
+                    description: DeviceDescription::try_from("Some other device").ok(),
+                    interface: crate::util::net::NetworkInterfaceName::try_from("tap1")?,
+                    tags: vec![DeviceTag::try_from("tag-2")?],
+                },
             ],
         };
 
@@ -128,22 +201,49 @@ mod tests {
             device_descriptors: vec![
                 DeviceDescriptor {
                     id: Some(Clone::clone(&device_id_1).into()),
-                    name: String::from("device-1"),
-                    description: String::from("Some device"),
-                    interface: Some(NetworkInterfaceName { name: String::from("tap0") }),
-                    tags: vec![String::from("tag-1"), String::from("tag-2")],
+                    name: Some(crate::proto::topology::DeviceName {
+                        value: String::from("device-1"),
+                    }),
+                    description: Some(crate::proto::topology::DeviceDescription {
+                        value: String::from("Some device"),
+                    }),
+                    interface: Some(NetworkInterfaceName {
+                        name: String::from("tap0"),
+                    }),
+                    tags: vec![
+                        Some(crate::proto::topology::DeviceTag {
+                            value: String::from("tag-1"),
+                        })
+                        .unwrap(),
+                        Some(crate::proto::topology::DeviceTag {
+                            value: String::from("tag-2"),
+                        })
+                        .unwrap(),
+                    ],
                 },
                 DeviceDescriptor {
                     id: Some(Clone::clone(&device_id_2).into()),
-                    name: String::from("device-2"),
-                    description: String::from("Some other device"),
-                    interface: Some(NetworkInterfaceName { name: String::from("tap1") }),
-                    tags: vec![String::from("tag-2")],
-                }
+                    name: Some(crate::proto::topology::DeviceName {
+                        value: String::from("device-2"),
+                    }),
+                    description: Some(crate::proto::topology::DeviceDescription {
+                        value: String::from("Some other device"),
+                    }),
+                    interface: Some(NetworkInterfaceName {
+                        name: String::from("tap1"),
+                    }),
+                    tags: vec![Some(crate::proto::topology::DeviceTag {
+                        value: String::from("tag-2"),
+                    })
+                    .unwrap()],
+                },
             ],
         };
 
-        verify_that!(native, eq(crate::topology::Topology::try_from(Clone::clone(&proto))?))?;
+        verify_that!(
+            native,
+            eq(crate::topology::Topology::try_from(Clone::clone(&proto))?)
+        )?;
 
         verify_that!(proto, eq(Topology::try_from(native)?))?;
 
@@ -151,23 +251,42 @@ mod tests {
     }
 
     #[test]
-    fn Converting_a_proto_Topology_to_a_native_Topology_should_fail_if_the_id_of_a_device_is_not_set() -> Result<()> {
-
+    fn Converting_a_proto_Topology_to_a_native_Topology_should_fail_if_the_id_of_a_device_is_not_set(
+    ) -> Result<()> {
         let proto = Topology {
-            device_descriptors: vec![
-                DeviceDescriptor {
-                    id: None,
-                    name: String::from("device-1"),
-                    description: String::from("Some device"),
-                    interface: Some(NetworkInterfaceName { name: String::from("tap0") }),
-                    tags: vec![String::from("tag-1"), String::from("tag-2")],
-                },
-            ],
+            device_descriptors: vec![DeviceDescriptor {
+                id: None,
+                name: Some(crate::proto::topology::DeviceName {
+                    value: String::from("device-1"),
+                }),
+                description: Some(crate::proto::topology::DeviceDescription {
+                    value: String::from("Some device"),
+                }),
+                interface: Some(NetworkInterfaceName {
+                    name: String::from("tap0"),
+                }),
+                tags: vec![
+                    Some(crate::proto::topology::DeviceTag {
+                        value: String::from("tag-1"),
+                    })
+                    .unwrap(),
+                    Some(crate::proto::topology::DeviceTag {
+                        value: String::from("tag-2"),
+                    })
+                    .unwrap(),
+                ],
+            }],
         };
 
         let result = crate::topology::Topology::try_from(proto);
 
-        verify_that!(result, err(eq(ConversionError::new::<DeviceDescriptor, crate::topology::DeviceDescriptor>("Id not set"))))?;
+        verify_that!(
+            result,
+            err(eq(ConversionError::new::<
+                DeviceDescriptor,
+                crate::topology::DeviceDescriptor,
+            >("Id not set")))
+        )?;
 
         Ok(())
     }
diff --git a/opendut-types/src/topology/mod.rs b/opendut-types/src/topology/mod.rs
index c3112f747..03061d8f4 100644
--- a/opendut-types/src/topology/mod.rs
+++ b/opendut-types/src/topology/mod.rs
@@ -1,7 +1,8 @@
 use std::fmt;
+use std::ops::Not;
 
-use serde::{Deserialize, Serialize};
 use crate::util::net::NetworkInterfaceName;
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
 pub struct Topology {
@@ -19,7 +20,6 @@ impl Topology {
 pub struct DeviceId(pub uuid::Uuid);
 
 impl DeviceId {
-
     pub const NIL: Self = Self(uuid::Uuid::from_bytes([0; 16]));
 
     pub fn random() -> Self {
@@ -45,11 +45,212 @@ impl From<uuid::Uuid> for DeviceId {
     }
 }
 
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub struct DeviceName(pub(crate) String);
+
+impl DeviceName {
+    pub const MIN_LENGTH: usize = 1;
+    pub const MAX_LENGTH: usize = 64;
+
+    pub fn value(&self) -> &str {
+        &self.0
+    }
+}
+
+#[derive(thiserror::Error, Clone, Debug)]
+pub enum IllegalDeviceName {
+    #[error("Device name '{value}' is too short. Expected at least {expected} characters, got {actual}.")]
+    TooShort {
+        value: String,
+        expected: usize,
+        actual: usize,
+    },
+    #[error(
+        "Device name '{value}' is too long. Expected at most {expected} characters, got {actual}."
+    )]
+    TooLong {
+        value: String,
+        expected: usize,
+        actual: usize,
+    },
+    #[error("Device name '{value}' contains invalid characters.")]
+    InvalidCharacter { value: String },
+}
+
+impl From<DeviceName> for String {
+    fn from(value: DeviceName) -> Self {
+        value.0
+    }
+}
+
+impl TryFrom<String> for DeviceName {
+    type Error = IllegalDeviceName;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        let length = value.len();
+        if length < Self::MIN_LENGTH {
+            Err(IllegalDeviceName::TooShort {
+                value,
+                expected: Self::MIN_LENGTH,
+                actual: length,
+            })
+        } else if length > Self::MAX_LENGTH {
+            Err(IllegalDeviceName::TooLong {
+                value,
+                expected: Self::MAX_LENGTH,
+                actual: length,
+            })
+        } else if crate::util::invalid_start_and_end_of_a_name(&value)
+            || value
+                .chars()
+                .any(|c| crate::util::valid_characters_in_name(&c).not())
+        {
+            Err(IllegalDeviceName::InvalidCharacter { value })
+        } else {
+            Ok(Self(value))
+        }
+    }
+}
+
+impl TryFrom<&str> for DeviceName {
+    type Error = IllegalDeviceName;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        DeviceName::try_from(value.to_owned())
+    }
+}
+
+impl fmt::Display for DeviceName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+#[derive(Clone, Debug, Eq, Default, PartialEq, Serialize, Deserialize)]
+pub struct DeviceDescription(pub(crate) String);
+
+impl DeviceDescription {
+    pub const MAX_LENGTH: usize = 280;
+
+    pub fn value(&self) -> &str {
+        &self.0
+    }
+}
+
+#[derive(thiserror::Error, Clone, Debug)]
+pub enum IllegalDeviceDescription {
+    #[error(
+    "Device description '{value}' is too long. Expected at most {expected} characters, got {actual}."
+    )]
+    TooLong {
+        value: String,
+        expected: usize,
+        actual: usize,
+    },
+}
+
+impl From<DeviceDescription> for String {
+    fn from(value: DeviceDescription) -> Self {
+        value.0
+    }
+}
+
+impl TryFrom<String> for DeviceDescription {
+    type Error = IllegalDeviceDescription;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        let length = value.len();
+        if length > Self::MAX_LENGTH {
+            Err(IllegalDeviceDescription::TooLong {
+                value,
+                expected: Self::MAX_LENGTH,
+                actual: length,
+            })
+        } else {
+            Ok(Self(value))
+        }
+    }
+}
+
+impl TryFrom<&str> for DeviceDescription {
+    type Error = IllegalDeviceDescription;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        DeviceDescription::try_from(value.to_owned())
+    }
+}
+
+impl fmt::Display for DeviceDescription {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTag(pub(crate) String);
+
+impl DeviceTag {
+    pub const MAX_LENGTH: usize = 64;
+
+    pub fn value(&self) -> &str {
+        &self.0
+    }
+}
+
+#[derive(thiserror::Error, Clone, Debug)]
+pub enum IllegalDeviceTag {
+    #[error(
+        "Device tag '{value}' is too long. Expected at most {expected} characters, got {actual}."
+    )]
+    TooLong {
+        value: String,
+        expected: usize,
+        actual: usize,
+    },
+}
+
+impl From<DeviceTag> for String {
+    fn from(value: DeviceTag) -> Self {
+        value.0
+    }
+}
+
+impl TryFrom<String> for DeviceTag {
+    type Error = IllegalDeviceTag;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        let length = value.len();
+        if length > Self::MAX_LENGTH {
+            Err(IllegalDeviceTag::TooLong {
+                value,
+                expected: Self::MAX_LENGTH,
+                actual: length,
+            })
+        } else {
+            Ok(Self(value))
+        }
+    }
+}
+
+impl TryFrom<&str> for DeviceTag {
+    type Error = IllegalDeviceTag;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        DeviceTag::try_from(value.to_owned())
+    }
+}
+
+impl fmt::Display for DeviceTag {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 pub struct DeviceDescriptor {
     pub id: DeviceId,
-    pub name: String,
-    pub description: String,
+    pub name: DeviceName,
+    pub description: Option<DeviceDescription>,
     pub interface: NetworkInterfaceName,
-    pub tags: Vec<String>,
+    pub tags: Vec<DeviceTag>,
 }
diff --git a/opendut-types/src/util/mod.rs b/opendut-types/src/util/mod.rs
index ff1ab3374..cb99e46f8 100644
--- a/opendut-types/src/util/mod.rs
+++ b/opendut-types/src/util/mod.rs
@@ -30,26 +30,20 @@ pub fn valid_characters_in_name(c: &char) -> bool {
     c.is_ascii_alphanumeric() || c.eq(&'-') || c.eq(&'_')
 }
 
-pub fn valid_start_and_end_of_a_name(string: &str) -> bool {
-    let invalid_begin_end_chars = vec!['_', '-'];
-    for char in invalid_begin_end_chars {
-        if string.starts_with(char) || string.ends_with(char) {
-            return false
-        }
-    }
-    true
+pub fn invalid_start_and_end_of_a_name(string: &str) -> bool {
+    const INVALID_BEGIN_END_CHARS: [char; 2] = ['_', '-'];
+    INVALID_BEGIN_END_CHARS
+        .iter()
+        .any(|&char| string.starts_with(char) || string.ends_with(char))
 }
 
-pub fn valid_start_and_end_of_location(string: &str) -> bool {
-    let invalid_begin_end_chars = vec!['_', '-', '/', ' ', '.', ','];
-    for char in invalid_begin_end_chars {
-        if string.starts_with(char) || string.ends_with(char) {
-            return false
-        }
-    }
-    true
+pub fn invalid_start_and_end_of_location(string: &str) -> bool {
+    const INVALID_BEGIN_END_CHARS: [char; 6] = ['_', '-', '/', ' ', '.', ','];
+    INVALID_BEGIN_END_CHARS
+        .iter()
+        .any(|&char| string.starts_with(char) || string.ends_with(char))
 }
 
 pub fn valid_characters_in_location(c: &char) -> bool {
-    c.is_ascii_alphanumeric() || matches!(c, '-'|'_'|'/'|' '|'.'|','|'('|')')
+    c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '/' | ' ' | '.' | ',' | '(' | ')')
 }