diff --git a/radicle-cli/examples/rad-config.md b/radicle-cli/examples/rad-config.md
index e47467da..e26fd17d 100644
--- a/radicle-cli/examples/rad-config.md
+++ b/radicle-cli/examples/rad-config.md
@@ -68,3 +68,81 @@ z6MksmpU5b1dS7oaqF2bHXhQi1DWy2hB7Mh9CuN7y1DN6QSz@seed.radicle.xyz:8776
 $ rad config get node.limits.routingMaxSize
 1000
 ```
+
+You can set scalar values by path.
+
+```
+$ rad config set node.alias bob
+bob
+$ rad config get node.alias
+bob
+```
+
+You can push a value to a collection by path.
+
+```
+$ rad config push web.pinned.repositories rad:z3TajuiHXifEDEX4qbJxe8nXr9ufi
+rad:z3TajuiHXifEDEX4qbJxe8nXr9ufi
+$ rad config push web.pinned.repositories rad:z3trNYnLWS11cJWC6BbxDs5niGo82
+rad:z3TajuiHXifEDEX4qbJxe8nXr9ufi
+rad:z3trNYnLWS11cJWC6BbxDs5niGo82
+```
+
+You can remove a value from a collection by path.
+
+```
+$ rad config remove web.pinned.repositories rad:z3TajuiHXifEDEX4qbJxe8nXr9ufi
+rad:z3trNYnLWS11cJWC6BbxDs5niGo82
+```
+
+Values that are not strictly required for a working configuration, such as
+optional values or additional user-defined values, can be deleted.
+
+```
+$ rad config set web.name alice
+alice
+$ rad config unset web.name
+```
+
+``` (fail)
+$ rad config get web.name
+✗ Error: configuration error: web.name does not exist
+```
+
+Values along the path will be created if necessary.
+
+```
+$ rad config set value.a.future.update.might.add.value 5
+5
+$ rad config push value.a.future.update.might.add.collection 1
+1
+```
+
+```
+$ rad config push node.array a
+a
+$ rad config push node.array b
+a
+b
+```
+
+Values that are required for a valid config can't be deleted.
+
+``` (fail)
+$ rad config unset node.alias
+✗ Error: configuration JSON error: missing field `alias`
+```
+
+Values for changes are being validated.
+
+``` (fail)
+$ rad config set web.pinned.repositories 5
+✗ Error: configuration JSON error: invalid type: integer `5`, expected a sequence
+```
+
+The type of the operation is validated.
+
+``` (fail)
+$ rad config push node.alias eve
+✗ Error: the element at the path 'node.alias' is not a JSON array
+```
diff --git a/radicle-cli/src/commands/config.rs b/radicle-cli/src/commands/config.rs
index 568a7089..56f00c92 100644
--- a/radicle-cli/src/commands/config.rs
+++ b/radicle-cli/src/commands/config.rs
@@ -6,7 +6,7 @@ use std::str::FromStr;
 
 use anyhow::anyhow;
 use radicle::node::Alias;
-use radicle::profile::Config;
+use radicle::profile::{Config, ConfigError, ConfigPath, RawConfig};
 
 use crate::terminal as term;
 use crate::terminal::args::{Args, Error, Help};
@@ -24,6 +24,10 @@ Usage
     rad config init --alias <alias> [<option>...]
     rad config edit [<option>...]
     rad config get <key> [<option>...]
+    rad config set <key> <value> [<option>...]
+    rad config unset <key> [<option>...]
+    rad config push <key> <value> [<option>...]
+    rad config remove <key> <value> [<option>...]
 
     If no argument is specified, prints the current radicle configuration as JSON.
     To initialize a new configuration file, use `rad config init`.
@@ -40,6 +44,10 @@ enum Operation {
     #[default]
     Show,
     Get(String),
+    Set(String, String),
+    Push(String, String),
+    Remove(String, String),
+    Unset(String),
     Init,
     Edit,
 }
@@ -75,11 +83,39 @@ impl Args for Options {
                     "edit" => op = Some(Operation::Edit),
                     "init" => op = Some(Operation::Init),
                     "get" => {
-                        let value = parser.value()?;
-                        let key = value.to_string_lossy();
-
+                        let key = parser.value()?;
+                        let key = key.to_string_lossy();
                         op = Some(Operation::Get(key.to_string()));
                     }
+                    "set" => {
+                        let key = parser.value()?;
+                        let key = key.to_string_lossy();
+                        let value = parser.value()?;
+                        let value = value.to_string_lossy();
+
+                        op = Some(Operation::Set(key.to_string(), value.to_string()));
+                    }
+                    "push" => {
+                        let key = parser.value()?;
+                        let key = key.to_string_lossy();
+                        let value = parser.value()?;
+                        let value = value.to_string_lossy();
+
+                        op = Some(Operation::Push(key.to_string(), value.to_string()));
+                    }
+                    "remove" => {
+                        let key = parser.value()?;
+                        let key = key.to_string_lossy();
+                        let value = parser.value()?;
+                        let value = value.to_string_lossy();
+
+                        op = Some(Operation::Remove(key.to_string(), value.to_string()));
+                    }
+                    "unset" => {
+                        let key = parser.value()?;
+                        let key = key.to_string_lossy();
+                        op = Some(Operation::Unset(key.to_string()));
+                    }
                     unknown => anyhow::bail!("unknown operation '{unknown}'"),
                 },
                 _ => return Err(anyhow!(arg.unexpected())),
@@ -106,11 +142,36 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
             term::json::to_pretty(&profile.config, path.as_path())?.print();
         }
         Operation::Get(key) => {
-            let profile = ctx.profile()?;
-            let data = serde_json::to_value(profile.config)?;
-            if let Some(value) = get_value(&data, &key) {
-                print_value(value)?;
-            }
+            let mut temp_config = RawConfig::from_file(&path)?;
+            let key: ConfigPath = key.into();
+            let value = temp_config
+                .get_mut(&key)
+                .ok_or_else(|| ConfigError::Custom(format!("{key} does not exist")))?;
+            print_value(value)?;
+        }
+        Operation::Set(key, value) => {
+            let mut temp_config = RawConfig::from_file(&path)?;
+            let value = temp_config.set(&key.into(), value.into())?;
+            temp_config.write(&path)?;
+            print_value(&value)?;
+        }
+        Operation::Push(key, value) => {
+            let mut temp_config = RawConfig::from_file(&path)?;
+            let value = temp_config.push(&key.into(), value.into())?;
+            temp_config.write(&path)?;
+            print_value(&value)?;
+        }
+        Operation::Remove(key, value) => {
+            let mut temp_config = RawConfig::from_file(&path)?;
+            let value = temp_config.remove(&key.into(), value.into())?;
+            temp_config.write(&path)?;
+            print_value(&value)?;
+        }
+        Operation::Unset(key) => {
+            let mut temp_config = RawConfig::from_file(&path)?;
+            let value = temp_config.unset(&key.into())?;
+            temp_config.write(&path)?;
+            print_value(&value)?;
         }
         Operation::Init => {
             if path.try_exists()? {
@@ -144,17 +205,6 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
     Ok(())
 }
 
-/// Get JSON value under a path.
-fn get_value<'a>(data: &'a serde_json::Value, path: &'a str) -> Option<&'a serde_json::Value> {
-    path.split('.').try_fold(data, |acc, key| {
-        if let serde_json::Value::Object(obj) = acc {
-            obj.get(key)
-        } else {
-            None
-        }
-    })
-}
-
 /// Print a JSON Value.
 fn print_value(value: &serde_json::Value) -> anyhow::Result<()> {
     match value {
diff --git a/radicle/src/profile.rs b/radicle/src/profile.rs
index ce08cb45..716acf66 100644
--- a/radicle/src/profile.rs
+++ b/radicle/src/profile.rs
@@ -10,31 +10,28 @@
 //!     node/
 //!       control.sock                           # Node control socket
 //!
-use std::io::Write;
+
+pub mod config;
+pub use config::{Config, ConfigError, ConfigPath, RawConfig};
+
 use std::path::{Path, PathBuf};
 use std::{fs, io};
 
 use localtime::LocalTime;
-use serde::Serialize;
-use serde_json as json;
 use thiserror::Error;
 
 use crate::crypto::ssh::agent::Agent;
 use crate::crypto::ssh::{keystore, Keystore, Passphrase};
 use crate::crypto::{PublicKey, Signer};
-use crate::explorer::Explorer;
-use crate::node::config::DefaultSeedingPolicy;
 use crate::node::policy::config::store::Read;
 use crate::node::{
-    notifications, policy,
-    policy::{Policy, Scope},
-    Alias, AliasStore, Handle as _, Node, UserAgent,
+    notifications, policy, policy::Scope, Alias, AliasStore, Handle as _, Node, UserAgent,
 };
 use crate::prelude::{Did, NodeId, RepoId};
 use crate::storage::git::transport;
 use crate::storage::git::Storage;
 use crate::storage::ReadRepository;
-use crate::{cli, cob, git, node, storage, web};
+use crate::{cob, git, node, storage};
 
 /// Environment variables used by radicle.
 pub mod env {
@@ -192,105 +189,6 @@ pub enum Error {
     Storage(#[from] storage::Error),
 }
 
-#[derive(Debug, Error)]
-pub enum ConfigError {
-    #[error("failed to load configuration from {0}: {1}")]
-    Io(PathBuf, io::Error),
-    #[error("failed to load configuration from {0}: {1}")]
-    Load(PathBuf, serde_json::Error),
-}
-
-/// Local radicle configuration.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Config {
-    /// Public explorer. This is used for generating links.
-    #[serde(default)]
-    pub public_explorer: Explorer,
-    /// Preferred seeds. These seeds will be used for explorer links
-    /// and in other situations when a seed needs to be chosen.
-    #[serde(default)]
-    pub preferred_seeds: Vec<node::config::ConnectAddress>,
-    /// Web configuration.
-    #[serde(default)]
-    pub web: web::Config,
-    /// CLI configuration.
-    #[serde(default)]
-    pub cli: cli::Config,
-    /// Node configuration.
-    pub node: node::Config,
-}
-
-impl Config {
-    /// Create a new, default configuration.
-    pub fn new(alias: Alias) -> Self {
-        let node = node::Config::new(alias);
-
-        Self {
-            public_explorer: Explorer::default(),
-            preferred_seeds: node.network.public_seeds(),
-            web: web::Config::default(),
-            cli: cli::Config::default(),
-            node,
-        }
-    }
-
-    /// Initialize a new configuration. Fails if the path already exists.
-    pub fn init(alias: Alias, path: &Path) -> io::Result<Self> {
-        let cfg = Config::new(alias);
-        cfg.write(path)?;
-
-        Ok(cfg)
-    }
-
-    /// Load a configuration from the given path.
-    pub fn load(path: &Path) -> Result<Self, ConfigError> {
-        let mut cfg: Self = match fs::File::open(path) {
-            Ok(cfg) => {
-                json::from_reader(cfg).map_err(|e| ConfigError::Load(path.to_path_buf(), e))?
-            }
-            Err(e) => return Err(ConfigError::Io(path.to_path_buf(), e)),
-        };
-
-        // Handle deprecated policy configuration.
-        // Nb. This will override "seedingPolicy" if set! This code should be removed after 1.0.
-        if let (Some(p), Some(s)) = (cfg.node.extra.get("policy"), cfg.node.extra.get("scope")) {
-            if let (Ok(policy), Ok(scope)) = (
-                json::from_value::<Policy>(p.clone()),
-                json::from_value::<Scope>(s.clone()),
-            ) {
-                log::warn!(target: "radicle", "Overwriting `seedingPolicy` configuration");
-                cfg.node.seeding_policy = match policy {
-                    Policy::Allow => DefaultSeedingPolicy::Allow { scope },
-                    Policy::Block => DefaultSeedingPolicy::Block,
-                }
-            }
-        }
-        Ok(cfg)
-    }
-
-    /// Write configuration to disk.
-    pub fn write(&self, path: &Path) -> Result<(), io::Error> {
-        let mut file = fs::OpenOptions::new()
-            .create_new(true)
-            .write(true)
-            .open(path)?;
-        let formatter = json::ser::PrettyFormatter::with_indent(b"  ");
-        let mut serializer = json::Serializer::with_formatter(&file, formatter);
-
-        self.serialize(&mut serializer)?;
-        file.write_all(b"\n")?;
-        file.sync_all()?;
-
-        Ok(())
-    }
-
-    /// Get the user alias.
-    pub fn alias(&self) -> &Alias {
-        &self.node.alias
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct Profile {
     pub home: Home,
@@ -735,9 +633,12 @@ impl Home {
 #[cfg(not(target_os = "macos"))]
 #[allow(clippy::unwrap_used)]
 mod test {
-    use super::*;
     use std::fs;
 
+    use serde_json as json;
+
+    use super::*;
+
     // Checks that if we have:
     // '/run/user/1000/.tmpqfK6ih/../.tmpqfK6ih/Radicle/Home'
     //
diff --git a/radicle/src/profile/config.rs b/radicle/src/profile/config.rs
new file mode 100644
index 00000000..f00d5d3b
--- /dev/null
+++ b/radicle/src/profile/config.rs
@@ -0,0 +1,362 @@
+use std::io::Write;
+use std::path::Path;
+use std::{fmt, fs, io};
+
+use serde::Serialize as _;
+use serde_json as json;
+use thiserror::Error;
+
+use crate::explorer::Explorer;
+use crate::node::config::DefaultSeedingPolicy;
+use crate::node::policy::{Policy, Scope};
+use crate::node::Alias;
+use crate::{cli, node, web};
+
+#[derive(Debug, Error)]
+pub enum ConfigError {
+    #[error("configuration I/O error: {0}")]
+    Io(#[from] io::Error),
+    #[error("configuration JSON error: {0}")]
+    Json(#[from] json::Error),
+    #[error("configuration error: {0}")]
+    Custom(String),
+}
+
+/// Local radicle configuration.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Config {
+    /// Public explorer. This is used for generating links.
+    #[serde(default)]
+    pub public_explorer: Explorer,
+    /// Preferred seeds. These seeds will be used for explorer links
+    /// and in other situations when a seed needs to be chosen.
+    #[serde(default)]
+    pub preferred_seeds: Vec<node::config::ConnectAddress>,
+    /// Web configuration.
+    #[serde(default)]
+    pub web: web::Config,
+    /// CLI configuration.
+    #[serde(default)]
+    pub cli: cli::Config,
+    /// Node configuration.
+    pub node: node::Config,
+}
+
+impl Config {
+    /// Create a new, default configuration.
+    pub fn new(alias: Alias) -> Self {
+        let node = node::Config::new(alias);
+
+        Self {
+            public_explorer: Explorer::default(),
+            preferred_seeds: node.network.public_seeds(),
+            web: web::Config::default(),
+            cli: cli::Config::default(),
+            node,
+        }
+    }
+
+    /// Initialize a new configuration. Fails if the path already exists.
+    pub fn init(alias: Alias, path: &Path) -> Result<Self, ConfigError> {
+        let cfg = Config::new(alias);
+        cfg.write(path)?;
+        Ok(cfg)
+    }
+
+    /// Load a configuration from the given path.
+    pub fn load(path: &Path) -> Result<Self, ConfigError> {
+        let mut cfg: Self = json::from_reader(fs::File::open(path)?)?;
+
+        // Handle deprecated policy configuration.
+        // Nb. This will override "seedingPolicy" if set! This code should be removed after 1.0.
+        if let (Some(p), Some(s)) = (cfg.node.extra.get("policy"), cfg.node.extra.get("scope")) {
+            if let (Ok(policy), Ok(scope)) = (
+                json::from_value::<Policy>(p.clone()),
+                json::from_value::<Scope>(s.clone()),
+            ) {
+                log::warn!(target: "radicle", "Overwriting `seedingPolicy` configuration");
+                cfg.node.seeding_policy = match policy {
+                    Policy::Allow => DefaultSeedingPolicy::Allow { scope },
+                    Policy::Block => DefaultSeedingPolicy::Block,
+                }
+            }
+        }
+        Ok(cfg)
+    }
+
+    /// Write configuration to disk.
+    pub fn write(&self, path: &Path) -> Result<(), ConfigError> {
+        let value = json::to_value(self)?;
+        let tmp = RawConfig(value);
+        let file = fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(path)?;
+
+        tmp.write_file(file)
+    }
+
+    /// Get the user alias.
+    pub fn alias(&self) -> &Alias {
+        &self.node.alias
+    }
+}
+
+/// Offers utility functions for editing the configuration. Validates on write.
+#[derive(Debug, Clone)]
+pub struct RawConfig(json::Value);
+
+#[derive(Debug, Error)]
+pub enum ModifyError {
+    #[error("the path provided was empty")]
+    EmptyPath,
+    #[error("could not find an element at the path '{path}'")]
+    NotFound { path: ConfigPath },
+    #[error("the element at the path '{path}' is not a JSON object")]
+    NotObject { path: ConfigPath },
+    #[error("the element at the path '{path}' is not a JSON array")]
+    NotArray { path: ConfigPath },
+    #[error("the parent element of '{key}' is not a JSON object")]
+    Upsert { key: String },
+}
+
+impl RawConfig {
+    /// Creates a temporary configuration, by reading a configuration file from disk.
+    pub fn from_file(path: &Path) -> Result<Self, ConfigError> {
+        let file = fs::File::open(path)?;
+        let config = json::from_reader(file)?;
+        Ok(RawConfig(config))
+    }
+
+    /// Get a mutable reference to a configuration value by path, if it exists.
+    pub fn get_mut(&mut self, config_path: &ConfigPath) -> Option<&mut json::Value> {
+        config_path
+            .iter()
+            .try_fold(&mut self.0, |current, part| current.get_mut(part))
+    }
+
+    /// Delete the specified path.
+    pub fn unset(&mut self, config_path: &ConfigPath) -> Result<json::Value, ModifyError> {
+        let last = config_path.last().ok_or(ModifyError::EmptyPath)?;
+        let parent = match config_path.parent() {
+            Some(parent_path) => {
+                self.get_mut(&parent_path)
+                    .ok_or_else(|| ModifyError::NotFound {
+                        path: config_path.clone(),
+                    })?
+            }
+            None => &mut self.0,
+        };
+
+        parent
+            .as_object_mut()
+            .ok_or_else(|| ModifyError::NotObject {
+                path: config_path.clone(),
+            })?
+            .remove(last);
+
+        Ok(json::Value::Null)
+    }
+
+    pub fn push(
+        &mut self,
+        config_path: &ConfigPath,
+        value: ConfigValue,
+    ) -> Result<json::Value, ModifyError> {
+        if let Some(element) = self.get_mut(config_path) {
+            let mut arr = element
+                .as_array()
+                .ok_or_else(|| ModifyError::NotArray {
+                    path: config_path.clone(),
+                })?
+                .to_vec();
+            arr.push(value.into());
+            *element = json::Value::Array(arr);
+
+            Ok(element.clone())
+        } else {
+            self.upsert(config_path, json::Value::Array(vec![value.into()]))
+        }
+    }
+
+    pub fn remove(
+        &mut self,
+        config_path: &ConfigPath,
+        value: ConfigValue,
+    ) -> Result<json::Value, ModifyError> {
+        let element = self
+            .get_mut(config_path)
+            .ok_or_else(|| ModifyError::NotFound {
+                path: config_path.clone(),
+            })?;
+        let arr = element
+            .as_array_mut()
+            .ok_or_else(|| ModifyError::NotArray {
+                path: config_path.clone(),
+            })?;
+        let value = json::Value::from(value);
+
+        arr.retain(|el| el != &value);
+        *element = json::Value::Array(arr.to_owned());
+
+        Ok(element.clone())
+    }
+
+    pub fn set(
+        &mut self,
+        config_path: &ConfigPath,
+        value: ConfigValue,
+    ) -> Result<json::Value, ModifyError> {
+        if let Some(element) = self.get_mut(config_path) {
+            *element = value.into();
+            Ok(element.clone())
+        } else {
+            self.upsert(config_path, value)
+        }
+    }
+
+    /// Writes the configuration, including extra values, to disk. Errors if the config is not
+    /// valid.
+    pub fn write(&self, path: &Path) -> Result<(), ConfigError> {
+        let _valid_config: Config = self.clone().try_into()?;
+        let file = fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(path)?;
+
+        self.write_file(file)
+    }
+
+    /// Write to an open file.
+    fn write_file(&self, mut file: fs::File) -> Result<(), ConfigError> {
+        let _valid_config: Config = self.clone().try_into()?;
+        let formatter = json::ser::PrettyFormatter::with_indent(b"  ");
+        let mut serializer = json::Serializer::with_formatter(&file, formatter);
+
+        self.0.serialize(&mut serializer)?;
+        file.write_all(b"\n")?;
+        file.sync_all()?;
+
+        Ok(())
+    }
+
+    /// Create an element at the given path, if it doesn't exist yet.
+    fn upsert(
+        &mut self,
+        config_path: &ConfigPath,
+        value: impl Into<json::Value>,
+    ) -> Result<json::Value, ModifyError> {
+        let mut current = &mut self.0;
+        for key in config_path.iter() {
+            current = match current {
+                json::Value::Object(ref mut map) => {
+                    map.entry(key).or_insert_with(|| json::json!({}))
+                }
+                _ => {
+                    return Err(ModifyError::Upsert {
+                        key: key.to_owned(),
+                    })
+                }
+            }
+        }
+        *current = value.into();
+
+        Ok(current.clone())
+    }
+}
+
+impl TryInto<Config> for RawConfig {
+    type Error = json::Error;
+
+    fn try_into(self) -> Result<Config, Self::Error> {
+        json::from_value(self.0)
+    }
+}
+
+/// A struct that ensures all values are safe for JSON serialization, including handling special
+/// floating point values like `NaN` and `Infinity`. Use the `From<&str>` implementation to create an instance.
+pub struct ConfigValue(RawConfigValue);
+
+/// This enum represents raw configuration values and should not be used directly.
+/// Use the `ConfigValue` type, which validates values using its `From<&str>` implementation.
+#[derive(Debug, Clone)]
+enum RawConfigValue {
+    Integer(i64),
+    Float(f64),
+    Bool(bool),
+    String(String),
+}
+
+impl From<&str> for ConfigValue {
+    /// Guess the type of a Value.
+    fn from(value: &str) -> Self {
+        if let Ok(b) = value.parse::<bool>() {
+            ConfigValue(RawConfigValue::Bool(b))
+        } else if let Ok(n) = value.parse::<i64>() {
+            ConfigValue(RawConfigValue::Integer(n))
+        } else if let Ok(n) = value.parse::<f64>() {
+            // NaN and Infinite can't be properly serialized to JSON
+            if n.is_finite() {
+                ConfigValue(RawConfigValue::Float(n))
+            } else {
+                ConfigValue(RawConfigValue::String(value.to_string()))
+            }
+        } else {
+            ConfigValue(RawConfigValue::String(value.to_string()))
+        }
+    }
+}
+
+impl From<String> for ConfigValue {
+    fn from(value: String) -> Self {
+        value.as_str().into()
+    }
+}
+
+impl From<ConfigValue> for json::Value {
+    fn from(value: ConfigValue) -> Self {
+        match value {
+            ConfigValue(RawConfigValue::Bool(v)) => json::Value::Bool(v),
+            ConfigValue(RawConfigValue::Integer(v)) => json::Value::Number(v.into()),
+            ConfigValue(RawConfigValue::Float(v)) => {
+                // SAFETY: ConfigValue ensures the Float won't be Infinite or NaN.
+                #[allow(clippy::unwrap_used)]
+                json::Value::Number(json::Number::from_f64(v).unwrap())
+            }
+            ConfigValue(RawConfigValue::String(v)) => json::Value::String(v),
+        }
+    }
+}
+
+/// Configuration attribute path.
+#[derive(Default, Debug, Clone)]
+pub struct ConfigPath(Vec<String>);
+
+impl ConfigPath {
+    fn parent(&self) -> Option<Self> {
+        self.0.split_last().map(|(_, tail)| Self(tail.to_vec()))
+    }
+
+    fn last(&self) -> Option<&str> {
+        self.0.last().map(AsRef::as_ref)
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &str> {
+        self.0.iter().map(|s| s.as_str())
+    }
+}
+
+impl fmt::Display for ConfigPath {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0.join("."))
+    }
+}
+
+impl From<String> for ConfigPath {
+    fn from(value: String) -> Self {
+        let parts: Vec<String> = value.split('.').map(|s| s.to_string()).collect();
+        ConfigPath(parts)
+    }
+}