diff --git a/.gitignore b/.gitignore
index 5fa23887..9a2038ec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,4 +2,8 @@
 **/node_modules/
 /src/x.rs
 
-.DS_Store
\ No newline at end of file
+.DS_Store
+
+# IDEs
+.idea
+.vscode
\ No newline at end of file
diff --git a/Cargo.lock b/Cargo.lock
index 304c85a2..5343b72a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -412,6 +412,16 @@ dependencies = [
  "nom",
 ]
 
+[[package]]
+name = "assert-json-diff"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "assert_cmd"
 version = "2.0.14"
@@ -2415,6 +2425,29 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "env_filter"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a009aa4810eb158359dda09d0c87378e4bbb89b5a801f016885a4707ba24f7ea"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c012a26a7f605efc424dd53697843a72be7dc86ad2d01f7814337794a12231d"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "humantime",
+ "log",
+]
+
 [[package]]
 name = "environmental"
 version = "1.1.4"
@@ -3154,6 +3187,12 @@ dependencies = [
  "libm",
 ]
 
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
 [[package]]
 name = "hyper"
 version = "0.14.28"
@@ -4422,6 +4461,25 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "mockito"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6e023aa5bdf392aa06c78e4a4e6d498baab5138d0c993503350ebbc37bf1e"
+dependencies = [
+ "assert-json-diff",
+ "colored",
+ "futures-core",
+ "hyper 0.14.28",
+ "log",
+ "rand",
+ "regex",
+ "serde_json",
+ "serde_urlencoded",
+ "similar",
+ "tokio",
+]
+
 [[package]]
 name = "multiaddr"
 version = "0.18.1"
@@ -5320,12 +5378,16 @@ dependencies = [
  "console",
  "dirs",
  "duct",
+ "env_logger",
  "git2",
  "os_info",
  "pop-contracts",
  "pop-parachains",
+ "pop-telemetry",
  "predicates",
  "reqwest",
+ "serde",
+ "serde_json",
  "sp-core 30.0.0",
  "sp-weights 29.0.0",
  "strum 0.26.2",
@@ -5381,6 +5443,23 @@ dependencies = [
  "zombienet-support",
 ]
 
+[[package]]
+name = "pop-telemetry"
+version = "0.1.0"
+dependencies = [
+ "dirs",
+ "env_logger",
+ "log",
+ "mockito",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "thiserror",
+ "tokio",
+ "url",
+]
+
 [[package]]
 name = "portable-atomic"
 version = "1.6.0"
@@ -6830,6 +6909,12 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a"
 
+[[package]]
+name = "similar"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
+
 [[package]]
 name = "simple-mermaid"
 version = "0.1.1"
diff --git a/Cargo.toml b/Cargo.toml
index 5ff96284..f9e4d4b2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,12 +12,22 @@ codegen-units = 1
 resolver = "2"
 members = ["crates/*"]
 
+[workspace.package]
+edition = "2021"
+
 [workspace.dependencies]
 anyhow = "1.0"
-thiserror = "1.0.58"
+dirs = "5.0"
+env_logger = "0.11.1"
 duct = "0.13"
 git2 = "0.18"
+log = "0.4.20"
+mockito = "1.4.0"
 tempfile = "3.8"
+thiserror = "1.0.58"
+
+# networking
+reqwest = { version = "0.11", features = ["json"] }
 tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
 url = { version = "2.5" }
 
@@ -37,7 +47,6 @@ walkdir = "2.4"
 indexmap = { version = "2.2" }
 toml_edit = { version = "0.22", features = ["serde"] }
 symlink = { version = "0.1" }
-reqwest = { version = "0.11" }
 serde_json = { version = "1.0" }
 serde = { version = "1.0", features = ["derive"] }
 zombienet-sdk = { git = "https://github.com/r0gue-io/zombienet-sdk", branch = "pop" }
diff --git a/crates/pop-cli/Cargo.toml b/crates/pop-cli/Cargo.toml
index 362db78d..ba21f832 100644
--- a/crates/pop-cli/Cargo.toml
+++ b/crates/pop-cli/Cargo.toml
@@ -2,7 +2,7 @@
 name = "pop-cli"
 description = "An all-in-one tool for Polkadot development."
 version = "0.1.0"
-edition = "2021"
+edition.workspace = true
 
 [[bin]]
 name = "pop"
@@ -11,11 +11,14 @@ path = "src/main.rs"
 [dependencies]
 anyhow.workspace = true
 duct.workspace = true
+env_logger.workspace = true
+os_info.workspace = true
+reqwest.workspace = true
+serde.workspace = true
+serde_json.workspace = true
 tempfile.workspace = true
-url.workspace = true
 tokio.workspace = true
-reqwest.workspace = true
-os_info.workspace = true
+url.workspace = true
 
 # pop-cli
 clap.workspace = true
@@ -34,12 +37,15 @@ pop-parachains = { path = "../pop-parachains", optional = true }
 dirs = { version = "5.0", optional = true }
 git2 = { workspace = true, features = ["vendored-openssl"] }
 
+# telemetry
+pop-telemetry = { path = "../pop-telemetry", optional = true }
+
 [dev-dependencies]
 assert_cmd = "2.0.14"
 predicates = "3.1.0"
 
 [features]
-default = ["contract", "parachain"]
+default = ["contract", "parachain", "telemetry"]
 contract = [
     "dep:pop-contracts",
     "dep:sp-core",
@@ -49,3 +55,4 @@ parachain = [
     "dep:pop-parachains",
     "dep:dirs",
 ]
+telemetry = ["dep:pop-telemetry"]
diff --git a/crates/pop-cli/src/commands/new/contract.rs b/crates/pop-cli/src/commands/new/contract.rs
index 54510d2e..5d2f679b 100644
--- a/crates/pop-cli/src/commands/new/contract.rs
+++ b/crates/pop-cli/src/commands/new/contract.rs
@@ -50,6 +50,7 @@ impl NewContractCommand {
 		let spinner = cliclack::spinner();
 		spinner.start("Generating contract...");
 		create_smart_contract(&self.name, contract_path.as_path())?;
+
 		spinner.stop("Smart contract created!");
 		outro(format!("cd into \"{}\" and enjoy hacking! 🚀", contract_path.display()))?;
 		Ok(())
diff --git a/crates/pop-cli/src/commands/new/pallet.rs b/crates/pop-cli/src/commands/new/pallet.rs
index 30e739ea..9f569823 100644
--- a/crates/pop-cli/src/commands/new/pallet.rs
+++ b/crates/pop-cli/src/commands/new/pallet.rs
@@ -55,6 +55,7 @@ impl NewPalletCommand {
 				description: self.description.clone().expect("default values"),
 			},
 		)?;
+
 		spinner.stop("Generation complete");
 		outro(format!("cd into \"{}\" and enjoy hacking! 🚀", &self.name))?;
 		Ok(())
diff --git a/crates/pop-cli/src/commands/new/parachain.rs b/crates/pop-cli/src/commands/new/parachain.rs
index 09733198..113bf742 100644
--- a/crates/pop-cli/src/commands/new/parachain.rs
+++ b/crates/pop-cli/src/commands/new/parachain.rs
@@ -5,11 +5,7 @@ use clap::{
 	builder::{PossibleValue, PossibleValuesParser, TypedValueParser},
 	Args,
 };
-use std::{
-	fs,
-	path::{Path, PathBuf},
-	str::FromStr,
-};
+use std::{fs, path::Path, str::FromStr};
 
 use cliclack::{clear_screen, confirm, input, intro, log, outro, outro_cancel, set_theme};
 use pop_parachains::{
@@ -20,7 +16,7 @@ use strum::VariantArray;
 
 const DEFAULT_INITIAL_ENDOWMENT: &str = "1u64 << 60";
 
-#[derive(Args)]
+#[derive(Args, Clone)]
 pub struct NewParachainCommand {
 	#[arg(help = "Name of the project. If empty assistance in the process will be provided.")]
 	pub(crate) name: Option<String>,
@@ -37,6 +33,12 @@ pub struct NewParachainCommand {
 		value_parser = crate::enum_variants!(Template)
 	)]
 	pub(crate) template: Option<Template>,
+	#[arg(
+		short = 'r',
+		long,
+		help = "Release tag to use for template. If empty, latest release will be used."
+	)]
+	pub(crate) release_tag: Option<String>,
 	#[arg(long, short, help = "Token Symbol", default_value = "UNIT")]
 	pub(crate) symbol: Option<String>,
 	#[arg(long, short, help = "Token Decimals", default_value = "12")]
@@ -48,12 +50,6 @@ pub struct NewParachainCommand {
 		default_value = DEFAULT_INITIAL_ENDOWMENT
 	)]
 	pub(crate) initial_endowment: Option<String>,
-	#[arg(
-		short = 'p',
-		long,
-		help = "Path for the parachain project, [default: current directory]"
-	)]
-	pub(crate) path: Option<PathBuf>,
 }
 
 #[macro_export]
@@ -72,53 +68,43 @@ macro_rules! enum_variants {
 }
 
 impl NewParachainCommand {
-	pub(crate) async fn execute(&self) -> Result<()> {
+	pub(crate) async fn execute(&self) -> Result<Template> {
 		clear_screen()?;
 		set_theme(Theme);
 
-		return match &self.name {
+		let parachain_config = if self.name.is_none() {
 			// If user doesn't select the name guide them to generate a parachain.
-			None => guide_user_to_generate_parachain().await,
-			Some(name) => {
-				let provider = &self.provider.clone().unwrap_or_default();
-				let template = match &self.template {
-					Some(template) => template.clone(),
-					None => provider.default_template(), // Each provider has a template by default
-				};
-
-				is_template_supported(provider, &template)?;
-				let mut initial_endowment = self.initial_endowment.clone();
-				if initial_endowment.is_some()
-					&& !is_initial_endowment_valid(&initial_endowment.clone().unwrap())
-				{
-					log::warning("⚠️ The specified initial endowment is not valid")?;
-					//Prompt the user if want to use the one by default
-					if !confirm(format!(
-						"📦 Would you like to use the default {}?",
-						DEFAULT_INITIAL_ENDOWMENT
-					))
-					.initial_value(true)
-					.interact()?
-					{
-						outro_cancel("🚫 Cannot create a parachain with an incorrect initial endowment value.")?;
-						return Ok(());
-					}
-					initial_endowment = Some(DEFAULT_INITIAL_ENDOWMENT.to_string());
-				}
-				let config = get_customization_value(
-					&template,
-					self.symbol.clone(),
-					self.decimals,
-					initial_endowment.clone(),
-				)?;
-
-				generate_parachain_from_template(name, provider, &template, None, config)
-			},
+			guide_user_to_generate_parachain().await?
+		} else {
+			self.clone()
 		};
+
+		let name = &parachain_config
+			.name
+			.clone()
+			.expect("name can not be none as fallback above is interactive input; qed");
+		let provider = &parachain_config.provider.clone().unwrap_or_default();
+		let template = match &parachain_config.template {
+			Some(template) => template.clone(),
+			None => provider.default_template(), // Each provider has a template by default
+		};
+
+		is_template_supported(provider, &template)?;
+		let config = get_customization_value(
+			&template,
+			parachain_config.symbol.clone(),
+			parachain_config.decimals,
+			parachain_config.initial_endowment.clone(),
+		)?;
+
+		let tag_version = parachain_config.release_tag.clone();
+
+		generate_parachain_from_template(name, provider, &template, tag_version, config)?;
+		Ok(template)
 	}
 }
 
-async fn guide_user_to_generate_parachain() -> Result<()> {
+async fn guide_user_to_generate_parachain() -> Result<NewParachainCommand> {
 	intro(format!("{}: Generate a parachain", style(" Pop CLI ").black().on_magenta()))?;
 
 	let mut prompt = cliclack::select("Select a template provider: ".to_string());
@@ -164,15 +150,16 @@ async fn guide_user_to_generate_parachain() -> Result<()> {
 
 	clear_screen()?;
 
-	generate_parachain_from_template(
-		&name,
-		&provider,
-		&template,
-		release_name,
-		customizable_options,
-	)
+	Ok(NewParachainCommand {
+		name: Some(name),
+		provider: Some(provider.clone()),
+		template: Some(template.clone()),
+		release_tag: release_name,
+		symbol: Some(customizable_options.symbol),
+		decimals: Some(customizable_options.decimals),
+		initial_endowment: Some(customizable_options.initial_endowment),
+	})
 }
-
 fn generate_parachain_from_template(
 	name_template: &String,
 	provider: &Provider,
@@ -187,6 +174,7 @@ fn generate_parachain_from_template(
 		template,
 		provider
 	))?;
+
 	let destination_path = check_destination_path(name_template)?;
 
 	let spinner = cliclack::spinner();
@@ -367,10 +355,10 @@ mod tests {
 			name: Some(dir.path().join("test_parachain").to_str().unwrap().to_string()),
 			provider: Some(Provider::Pop),
 			template: Some(Template::Standard),
+			release_tag: None,
 			symbol: Some("UNIT".to_string()),
 			decimals: Some(12),
 			initial_endowment: Some("1u64 << 60".to_string()),
-			path: None,
 		};
 		command.execute().await?;
 
diff --git a/crates/pop-cli/src/commands/test/contract.rs b/crates/pop-cli/src/commands/test/contract.rs
index 73a24b3f..61aedb98 100644
--- a/crates/pop-cli/src/commands/test/contract.rs
+++ b/crates/pop-cli/src/commands/test/contract.rs
@@ -17,20 +17,24 @@ pub(crate) struct TestContractCommand {
 }
 
 impl TestContractCommand {
-	pub(crate) fn execute(&self) -> anyhow::Result<()> {
+	pub(crate) fn execute(&self) -> anyhow::Result<&str> {
 		clear_screen()?;
+
 		if self.features.is_some() && self.features.clone().unwrap().contains("e2e-tests") {
 			intro(format!(
 				"{}: Starting end-to-end tests",
 				style(" Pop CLI ").black().on_magenta()
 			))?;
+
 			test_e2e_smart_contract(&self.path)?;
 			outro("End-to-end testing complete")?;
+			Ok("e2e")
 		} else {
 			intro(format!("{}: Starting unit tests", style(" Pop CLI ").black().on_magenta()))?;
+
 			test_smart_contract(&self.path)?;
 			outro("Unit testing complete")?;
+			Ok("unit")
 		}
-		Ok(())
 	}
 }
diff --git a/crates/pop-cli/src/commands/up/contract.rs b/crates/pop-cli/src/commands/up/contract.rs
index 1c75cf9e..14bcbb7c 100644
--- a/crates/pop-cli/src/commands/up/contract.rs
+++ b/crates/pop-cli/src/commands/up/contract.rs
@@ -55,6 +55,7 @@ impl UpContractCommand {
 	pub(crate) async fn execute(&self) -> anyhow::Result<()> {
 		clear_screen()?;
 		intro(format!("{}: Deploy a smart contract", style(" Pop CLI ").black().on_magenta()))?;
+
 		let instantiate_exec = set_up_deployment(UpOpts {
 			path: self.path.clone(),
 			constructor: self.constructor.clone(),
diff --git a/crates/pop-cli/src/commands/up/parachain.rs b/crates/pop-cli/src/commands/up/parachain.rs
index 8939a3d6..06abc3a1 100644
--- a/crates/pop-cli/src/commands/up/parachain.rs
+++ b/crates/pop-cli/src/commands/up/parachain.rs
@@ -35,6 +35,7 @@ impl ZombienetCommand {
 		clear_screen()?;
 		intro(format!("{}: Deploy a parachain", style(" Pop CLI ").black().on_magenta()))?;
 		set_theme(Theme);
+
 		// Parse arguments
 		let cache = crate::cache()?;
 		let mut zombienet = Zombienet::new(
diff --git a/crates/pop-cli/src/main.rs b/crates/pop-cli/src/main.rs
index 032d004b..fbf4d1cd 100644
--- a/crates/pop-cli/src/main.rs
+++ b/crates/pop-cli/src/main.rs
@@ -11,6 +11,10 @@ mod style;
 use anyhow::anyhow;
 use anyhow::Result;
 use clap::{Parser, Subcommand};
+use commands::*;
+#[cfg(feature = "telemetry")]
+use pop_telemetry::{config_file_path, record_cli_command, record_cli_used, Telemetry};
+use serde_json::{json, Value};
 #[cfg(feature = "parachain")]
 use std::{fs::create_dir_all, path::PathBuf};
 
@@ -27,68 +31,105 @@ enum Commands {
 	/// Generate a new parachain, pallet or smart contract.
 	#[clap(alias = "n")]
 	#[cfg(any(feature = "parachain", feature = "contract"))]
-	New(commands::new::NewArgs),
+	New(new::NewArgs),
 	/// Build a parachain or smart contract.
 	#[clap(alias = "b")]
 	#[cfg(any(feature = "parachain", feature = "contract"))]
-	Build(commands::build::BuildArgs),
+	Build(build::BuildArgs),
 	/// Call a smart contract.
 	#[clap(alias = "c")]
 	#[cfg(feature = "contract")]
-	Call(commands::call::CallArgs),
+	Call(call::CallArgs),
 	/// Deploy a parachain or smart contract.
 	#[clap(alias = "u")]
 	#[cfg(any(feature = "parachain", feature = "contract"))]
-	Up(commands::up::UpArgs),
+	Up(up::UpArgs),
 	/// Test a smart contract.
 	#[clap(alias = "t")]
 	#[cfg(feature = "contract")]
-	Test(commands::test::TestArgs),
+	Test(test::TestArgs),
 	/// Set up the environment for development by installing required packages
 	#[clap(alias = "i")]
-	Install(commands::install::InstallArgs),
+	Install(install::InstallArgs),
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
+	#[cfg(feature = "telemetry")]
+	let maybe_tel = init().unwrap_or(None);
+
 	let cli = Cli::parse();
-	match cli.command {
+	let res = match cli.command {
 		#[cfg(any(feature = "parachain", feature = "contract"))]
-		Commands::New(args) => match &args.command {
+		Commands::New(args) => match args.command {
 			#[cfg(feature = "parachain")]
-			commands::new::NewCommands::Parachain(cmd) => cmd.execute().await,
+			new::NewCommands::Parachain(cmd) => match cmd.execute().await {
+				Ok(template) => {
+					// telemetry should never cause a panic or early exit
+					Ok(json!({template.provider().unwrap_or("provider-missing"): template.name()}))
+				},
+				Err(e) => Err(e),
+			},
 			#[cfg(feature = "parachain")]
-			commands::new::NewCommands::Pallet(cmd) => cmd.execute().await,
+			new::NewCommands::Pallet(cmd) => {
+				// When more contract selections are added the tel data will likely need to go deeper in the stack
+				cmd.execute().await.map(|_| json!("template"))
+			},
 			#[cfg(feature = "contract")]
-			commands::new::NewCommands::Contract(cmd) => cmd.execute().await,
+			new::NewCommands::Contract(cmd) => {
+				// When more contract selections are added, the tel data will likely need to go deeper in the stack
+				cmd.execute().await.map(|_| json!("default"))
+			},
 		},
 		#[cfg(any(feature = "parachain", feature = "contract"))]
 		Commands::Build(args) => match &args.command {
 			#[cfg(feature = "parachain")]
-			commands::build::BuildCommands::Parachain(cmd) => cmd.execute(),
+			build::BuildCommands::Parachain(cmd) => cmd.execute().map(|_| Value::Null),
 			#[cfg(feature = "contract")]
-			commands::build::BuildCommands::Contract(cmd) => cmd.execute(),
+			build::BuildCommands::Contract(cmd) => cmd.execute().map(|_| Value::Null),
 		},
 		#[cfg(feature = "contract")]
 		Commands::Call(args) => match &args.command {
-			commands::call::CallCommands::Contract(cmd) => cmd.execute().await,
+			call::CallCommands::Contract(cmd) => cmd.execute().await.map(|_| Value::Null),
 		},
 		#[cfg(any(feature = "parachain", feature = "contract"))]
 		Commands::Up(args) => match &args.command {
 			#[cfg(feature = "parachain")]
-			commands::up::UpCommands::Parachain(cmd) => cmd.execute().await,
+			up::UpCommands::Parachain(cmd) => cmd.execute().await.map(|_| Value::Null),
 			#[cfg(feature = "contract")]
-			commands::up::UpCommands::Contract(cmd) => cmd.execute().await,
+			up::UpCommands::Contract(cmd) => cmd.execute().await.map(|_| Value::Null),
 		},
 		#[cfg(feature = "contract")]
 		Commands::Test(args) => match &args.command {
-			commands::test::TestCommands::Contract(cmd) => cmd.execute(),
+			test::TestCommands::Contract(cmd) => match cmd.execute() {
+				Ok(feature) => Ok(json!(feature)),
+				Err(e) => Err(e),
+			},
 		},
 		#[cfg(any(feature = "parachain", feature = "contract"))]
-		Commands::Install(args) => args.execute().await,
+		Commands::Install(args) => args.execute().await.map(|_| Value::Null),
+	};
+
+	#[cfg(feature = "telemetry")]
+	if let Some(tel) = maybe_tel.clone() {
+		// `args` is guaranteed to have at least 3 elements as clap will display help message if not set.
+		let args: Vec<_> = std::env::args().collect();
+		let command = args.get(1).expect("expected command missing");
+		let subcommand = args.get(2).expect("expected sub-command missing");
+
+		if let Ok(sub_data) = &res {
+			// Best effort to send on first try, no action if failure.
+			let _ =
+				record_cli_command(tel.clone(), command, json!({subcommand: sub_data.to_string()}))
+					.await;
+		} else {
+			let _ = record_cli_command(tel, "error", json!({command: subcommand})).await;
+		}
 	}
-}
 
+	// map result from Result<Value> to Result<()>
+	res.map(|_| ())
+}
 #[cfg(feature = "parachain")]
 fn cache() -> Result<PathBuf> {
 	let cache_path = dirs::cache_dir()
@@ -99,6 +140,23 @@ fn cache() -> Result<PathBuf> {
 	Ok(cache_path)
 }
 
+#[cfg(feature = "telemetry")]
+fn init() -> Result<Option<Telemetry>> {
+	env_logger::init();
+	let maybe_config_path = config_file_path();
+
+	let maybe_tel = maybe_config_path.ok().map(|path| Telemetry::new(path));
+
+	// Handle for await not used here as telemetry should complete before any of the commands do.
+	// Sends a generic ping saying the CLI was used.
+	if let Some(tel) = maybe_tel.clone() {
+		tokio::spawn(record_cli_used(tel));
+	}
+
+	// if config file errors set telemetry to None, otherwise Some(tel)
+	Ok(maybe_tel)
+}
+
 #[test]
 fn verify_cli() {
 	// https://docs.rs/clap/latest/clap/_derive/_tutorial/chapter_4/index.html
diff --git a/crates/pop-contracts/Cargo.toml b/crates/pop-contracts/Cargo.toml
index 1a23c265..3be223b8 100644
--- a/crates/pop-contracts/Cargo.toml
+++ b/crates/pop-contracts/Cargo.toml
@@ -2,8 +2,8 @@
 name = "pop-contracts"
 description = "Library for generating, building, deploying and calling ink! smart contracts."
 version = "0.1.0"
-edition = "2021"
 license = "Apache-2.0"
+edition.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/crates/pop-parachains/Cargo.toml b/crates/pop-parachains/Cargo.toml
index 8bd91305..d023f8ae 100644
--- a/crates/pop-parachains/Cargo.toml
+++ b/crates/pop-parachains/Cargo.toml
@@ -2,8 +2,8 @@
 name = "pop-parachains"
 description = "Library for generating, building and running parachains."
 version = "0.1.0"
-edition = "2021"
 license = "Apache-2.0"
+edition.workspace = true
 
 [dependencies]
 anyhow.workspace = true
diff --git a/crates/pop-parachains/src/templates.rs b/crates/pop-parachains/src/templates.rs
index 7cf29691..e2935ced 100644
--- a/crates/pop-parachains/src/templates.rs
+++ b/crates/pop-parachains/src/templates.rs
@@ -144,12 +144,18 @@ impl Template {
 	pub fn repository_url(&self) -> Result<&str, Error> {
 		self.get_str("Repository").ok_or(Error::RepositoryMissing)
 	}
+
+	pub fn provider(&self) -> Result<&str, Error> {
+		self.get_str("Provider").ok_or(Error::ProviderMissing)
+	}
 }
 
 #[derive(Error, Debug)]
 pub enum Error {
 	#[error("The `Repository` property is missing from the template variant")]
 	RepositoryMissing,
+	#[error("The `Provider` property is missing from the template variant")]
+	ProviderMissing,
 }
 
 #[cfg(test)]
diff --git a/crates/pop-telemetry/Cargo.toml b/crates/pop-telemetry/Cargo.toml
new file mode 100644
index 00000000..55c7a077
--- /dev/null
+++ b/crates/pop-telemetry/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "pop-telemetry"
+version = "0.1.0"
+edition.workspace = true
+
+[dependencies]
+dirs = { workspace = true }
+env_logger.workspace = true
+log.workspace = true
+reqwest.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+url.workspace = true
+
+[dev-dependencies]
+tempfile.workspace = true
+mockito.workspace = true
\ No newline at end of file
diff --git a/crates/pop-telemetry/src/lib.rs b/crates/pop-telemetry/src/lib.rs
new file mode 100644
index 00000000..d24458dc
--- /dev/null
+++ b/crates/pop-telemetry/src/lib.rs
@@ -0,0 +1,330 @@
+use reqwest::Client;
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde_json::{json, Value};
+use std::{
+	fs::{create_dir_all, File},
+	io,
+	io::{Read, Write},
+	path::PathBuf,
+};
+use thiserror::Error;
+
+const ENDPOINT: &str = "https://insights.onpop.io/api/send";
+const WEBSITE_ID: &str = "0cbea0ba-4752-45aa-b3cd-8fd11fa722f7";
+const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[derive(Error, Debug)]
+pub enum TelemetryError {
+	#[error("a reqwest error occurred: {0}")]
+	NetworkError(reqwest::Error),
+	#[error("io error occurred: {0}")]
+	IO(io::Error),
+	#[error("opt-out has been set, can not report metrics")]
+	OptedOut,
+	#[error("unable to find config file")]
+	ConfigFileNotFound,
+	#[error("serialization failed: {0}")]
+	SerializeFailed(String),
+}
+
+pub type Result<T> = std::result::Result<T, TelemetryError>;
+
+#[derive(Debug, Clone)]
+pub struct Telemetry {
+	// Endpoint to the telemetry API.
+	// This should include the domain and api path (e.g. localhost:3000/api/send)
+	endpoint: String,
+	// Has the user opted-out to anonymous telemetry
+	opt_out: bool,
+	// Reqwest client
+	client: Client,
+}
+
+impl Telemetry {
+	/// Create a new Telemetry instance.
+	///
+	/// parameters:
+	/// `config_path`: the path to the configuration file (used for opt-out checks)
+	pub fn new(config_path: PathBuf) -> Self {
+		Self::init(ENDPOINT.to_string(), config_path)
+	}
+
+	/// Initialize a new Telemetry instance with parameters.
+	/// Can be used in tests to provide mock endpoints.
+	/// parameters:
+	/// `endpoint`: the API endpoint that telemetry will call
+	///	`config_path`: the path to the configuration file (used for opt-out checks)
+	fn init(endpoint: String, config_path: PathBuf) -> Self {
+		let opt_out = Self::is_opt_out_from_config(&config_path);
+
+		Telemetry { endpoint, opt_out, client: Client::new() }
+	}
+
+	fn is_opt_out_from_config(config_file_path: &PathBuf) -> bool {
+		let config: Config = match read_json_file(config_file_path) {
+			Ok(config) => config,
+			Err(err) => {
+				log::debug!("{:?}", err.to_string());
+				return false;
+			},
+		};
+
+		!config.opt_out.version.is_empty()
+	}
+
+	/// Send JSON payload to saved api endpoint.
+	/// Returns error and will not send anything if opt-out is true.
+	/// Returns error from reqwest if the sending fails.
+	/// It sends message only once as "best effort". There is no retry on error
+	/// in order to keep overhead to a minimal.
+	async fn send_json(&self, payload: Value) -> Result<()> {
+		if self.opt_out {
+			return Err(TelemetryError::OptedOut);
+		}
+
+		let request_builder = self.client.post(&self.endpoint);
+
+		request_builder
+			.json(&payload)
+			.send()
+			.await
+			.map_err(TelemetryError::NetworkError)?;
+
+		Ok(())
+	}
+}
+
+/// Generically reports that the CLI was used to the telemetry endpoint.
+/// There is explicitly no reqwest retries on failure to ensure overhead
+/// stays to a minimum.
+pub async fn record_cli_used(tel: Telemetry) -> Result<()> {
+	let payload = generate_payload("", json!({}));
+
+	let res = tel.send_json(payload).await;
+	log::debug!("send_cli_used result: {:?}", res);
+
+	res
+}
+
+/// Reports what CLI command was called to telemetry.
+///
+/// parameters:
+/// `command_name`: the name of the command entered (new, up, build, etc)
+/// `data`: the JSON representation of subcommands. This should never include any user inputted
+/// data like a file name.
+pub async fn record_cli_command(tel: Telemetry, command_name: &str, data: Value) -> Result<()> {
+	let payload = generate_payload(command_name, data);
+
+	let res = tel.send_json(payload).await;
+	log::debug!("send_cli_used result: {:?}", res);
+
+	res
+}
+
+#[derive(PartialEq, Serialize, Deserialize, Debug)]
+struct OptOut {
+	// what telemetry version did they opt-out for
+	version: String,
+}
+
+/// Type to represent pop cli configuration.
+/// This will be written as json to a config.json file.
+#[derive(PartialEq, Serialize, Deserialize, Debug)]
+pub struct Config {
+	opt_out: OptOut,
+}
+
+/// Returns the configuration file path based on OS's default config directory.
+pub fn config_file_path() -> Result<PathBuf> {
+	let config_path = dirs::config_dir().ok_or(TelemetryError::ConfigFileNotFound)?.join("pop");
+	// Creates pop dir if needed
+	create_dir_all(config_path.as_path()).map_err(|err| TelemetryError::IO(err))?;
+	Ok(config_path.join("config.json"))
+}
+
+/// Writes opt-out to the configuration file at the specified path.
+/// opt-out is currently the only config type. Hence, if the file exists, it will be overwritten.
+///
+/// parameters:
+/// `config_path`: the path to write the config file to
+pub fn write_config_opt_out(config_path: &PathBuf) -> Result<()> {
+	let config = Config { opt_out: OptOut { version: CARGO_PKG_VERSION.to_string() } };
+
+	let config_json = serde_json::to_string_pretty(&config)
+		.map_err(|err| TelemetryError::SerializeFailed(err.to_string()))?;
+
+	// overwrites file if it exists
+	let mut file = File::create(&config_path).map_err(|err| TelemetryError::IO(err))?;
+	file.write_all(config_json.as_bytes()).map_err(|err| TelemetryError::IO(err))?;
+
+	Ok(())
+}
+
+fn read_json_file<T>(file_path: &PathBuf) -> std::result::Result<T, io::Error>
+where
+	T: DeserializeOwned,
+{
+	let mut file = File::open(file_path)?;
+
+	let mut json = String::new();
+	file.read_to_string(&mut json)?;
+
+	let deserialized: T = serde_json::from_str(&json)?;
+
+	Ok(deserialized)
+}
+
+fn generate_payload(event_name: &str, data: Value) -> Value {
+	json!({
+		"payload": {
+			"hostname": "cli",
+			"language": "en-US",
+			"referrer": "",
+			"screen": "1920x1080",
+			"title": CARGO_PKG_VERSION,
+			"url": "/",
+			"website": WEBSITE_ID,
+			"name": event_name,
+			"data": data
+		},
+		"type": "event"
+	})
+}
+
+#[cfg(test)]
+mod tests {
+
+	use super::*;
+	use mockito::{Matcher, Mock, Server};
+	use serde_json::json;
+	use tempfile::TempDir;
+
+	fn create_temp_config(temp_dir: &TempDir) -> PathBuf {
+		let config_path = temp_dir.path().join("config.json");
+		assert!(write_config_opt_out(&config_path).is_ok());
+		config_path
+	}
+	async fn default_mock(mock_server: &mut Server, payload: String) -> Mock {
+		mock_server
+			.mock("POST", "/api/send")
+			.match_header("content-type", "application/json")
+			.match_header("accept", "*/*")
+			.match_body(Matcher::JsonString(payload.clone()))
+			.match_header("content-length", payload.len().to_string().as_str())
+			.match_header("host", mock_server.host_with_port().trim())
+			.create_async()
+			.await
+	}
+	#[tokio::test]
+	async fn write_config_opt_out_works() {
+		// Mock config file path function to return a temporary path
+		let temp_dir = TempDir::new().unwrap();
+		let config_path = create_temp_config(&temp_dir);
+
+		let actual_config: Config = read_json_file(&config_path).unwrap();
+		let expected_config = Config { opt_out: OptOut { version: CARGO_PKG_VERSION.to_string() } };
+
+		assert_eq!(actual_config, expected_config);
+	}
+
+	#[tokio::test]
+	async fn new_telemetry_works() {
+		let _ = env_logger::try_init();
+		// assert that invalid config file results in a false opt_in (hence disabling telemetry)
+		assert!(!Telemetry::init("".to_string(), PathBuf::new()).opt_out);
+
+		// Mock config file path function to return a temporary path
+		let temp_dir = TempDir::new().unwrap();
+		let config_path = create_temp_config(&temp_dir);
+
+		let _: Config = read_json_file(&config_path).unwrap();
+
+		let tel = Telemetry::init("127.0.0.1".to_string(), config_path);
+		let expected_telemetry = Telemetry {
+			endpoint: "127.0.0.1".to_string(),
+			opt_out: true,
+			client: Default::default(),
+		};
+
+		assert_eq!(tel.endpoint, expected_telemetry.endpoint);
+		assert_eq!(tel.opt_out, expected_telemetry.opt_out);
+	}
+
+	#[tokio::test]
+	async fn test_record_cli_used() {
+		let _ = env_logger::try_init();
+		let mut mock_server = mockito::Server::new_async().await;
+
+		let mut endpoint = mock_server.url();
+		endpoint.push_str("/api/send");
+
+		// Mock config file path function to return a temporary path
+		let temp_dir = TempDir::new().unwrap();
+		let config_path = temp_dir.path().join("config.json");
+
+		let expected_payload = generate_payload("", json!({})).to_string();
+
+		let mock = default_mock(&mut mock_server, expected_payload).await;
+
+		let tel = Telemetry::init(endpoint.clone(), config_path);
+
+		assert!(record_cli_used(tel).await.is_ok());
+		mock.assert_async().await;
+	}
+
+	#[tokio::test]
+	async fn test_record_cli_command() {
+		let _ = env_logger::try_init();
+		let mut mock_server = mockito::Server::new_async().await;
+
+		let mut endpoint = mock_server.url();
+		endpoint.push_str("/api/send");
+
+		// Mock config file path function to return a temporary path
+		let temp_dir = TempDir::new().unwrap();
+
+		let config_path = temp_dir.path().join("config.json");
+
+		let expected_payload = generate_payload("new", json!("parachain")).to_string();
+
+		let mock = default_mock(&mut mock_server, expected_payload).await;
+
+		let tel = Telemetry::init(endpoint.clone(), config_path);
+
+		assert!(record_cli_command(tel, "new", json!("parachain")).await.is_ok());
+		mock.assert_async().await;
+	}
+
+	#[tokio::test]
+	async fn opt_out_fails() {
+		let _ = env_logger::try_init();
+		let mut mock_server = mockito::Server::new_async().await;
+
+		let endpoint = mock_server.url();
+
+		// Mock config file path function to return a temporary path
+		let temp_dir = TempDir::new().unwrap();
+		let config_path = create_temp_config(&temp_dir);
+
+		let mock = mock_server.mock("POST", "/").create_async().await;
+		let mock = mock.expect_at_most(0);
+
+		let mut tel = Telemetry::init(endpoint.clone(), config_path);
+
+		assert!(matches!(tel.send_json(json!("foo")).await, Err(TelemetryError::OptedOut)));
+		assert!(matches!(record_cli_used(tel.clone()).await, Err(TelemetryError::OptedOut)));
+		assert!(matches!(
+			record_cli_command(tel.clone(), "foo", json!("bar")).await,
+			Err(TelemetryError::OptedOut)
+		));
+		mock.assert_async().await;
+
+		// test it's set to true and works
+		tel.opt_out = false;
+		let mock = mock.expect_at_most(3);
+		assert!(tel.send_json(json!("foo")).await.is_ok(),);
+		assert!(record_cli_used(tel.clone()).await.is_ok());
+		assert!(record_cli_command(tel, "foo", json!("bar")).await.is_ok());
+		mock.assert_async().await;
+	}
+}