diff --git a/applications/tari_dan_app_utilities/src/template_manager/implementation/manager.rs b/applications/tari_dan_app_utilities/src/template_manager/implementation/manager.rs
index 50b7b7387..5846158c5 100644
--- a/applications/tari_dan_app_utilities/src/template_manager/implementation/manager.rs
+++ b/applications/tari_dan_app_utilities/src/template_manager/implementation/manager.rs
@@ -20,9 +20,15 @@
 //  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 //  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use std::{collections::HashMap, convert::TryFrom, fs, sync::Arc};
+use std::{
+    collections::HashMap,
+    convert::TryFrom,
+    fs,
+    sync::Arc,
+    time::{SystemTime, UNIX_EPOCH},
+};
 
-use chrono::Utc;
+use chrono::{Duration, Utc};
 use log::*;
 use tari_common_types::types::{FixedHash, PublicKey};
 use tari_crypto::tari_utilities::ByteArray;
@@ -48,7 +54,6 @@ use tari_template_builtin::{
     FAUCET_TEMPLATE_ADDRESS,
 };
 use tari_template_lib::{models::TemplateAddress, Hash};
-use tokio::sync::broadcast;
 
 use super::TemplateConfig;
 use crate::template_manager::{
@@ -60,6 +65,12 @@ const LOG_TARGET: &str = "tari::validator_node::template_manager";
 
 const CONCURRENT_ACCESS_LIMIT: isize = 100;
 
+#[derive(Debug, Clone)]
+pub enum TemplateResult {
+    Template(Box<Template>),
+    PendingTemplate,
+}
+
 #[derive(Debug)]
 pub struct TemplateManager<TAddr> {
     global_db: GlobalDb<SqliteGlobalDbAdapter<TAddr>>,
@@ -132,21 +143,25 @@ impl<TAddr: NodeAddressable> TemplateManager<TAddr> {
         }
     }
 
-    pub fn template_exists(&self, address: &TemplateAddress) -> Result<bool, TemplateManagerError> {
+    pub fn template_exists(
+        &self,
+        address: &TemplateAddress,
+        status: TemplateStatus,
+    ) -> Result<bool, TemplateManagerError> {
         if self.builtin_templates.contains_key(address) {
             return Ok(true);
         }
         let mut tx = self.global_db.create_transaction()?;
         self.global_db
             .templates(&mut tx)
-            .template_exists(address)
+            .template_exists(address, status)
             .map_err(|_| TemplateManagerError::TemplateNotFound { address: *address })
     }
 
-    pub fn fetch_template(&self, address: &TemplateAddress) -> Result<Template, TemplateManagerError> {
+    pub fn fetch_template(&self, address: &TemplateAddress) -> Result<TemplateResult, TemplateManagerError> {
         // first of all, check if the address is for a bulitin template
         if let Some(template) = self.builtin_templates.get(address) {
-            return Ok(template.to_owned());
+            return Ok(TemplateResult::Template(Box::new(template.to_owned())));
         }
 
         let mut tx = self.global_db.create_transaction()?;
@@ -156,6 +171,11 @@ impl<TAddr: NodeAddressable> TemplateManager<TAddr> {
             .get_template(address)?
             .ok_or(TemplateManagerError::TemplateNotFound { address: *address })?;
 
+        // notify the caller that the template is under sync, so not yet ready
+        if matches!(template.status, TemplateStatus::Pending) {
+            return Ok(TemplateResult::PendingTemplate);
+        }
+
         if !matches!(template.status, TemplateStatus::Active | TemplateStatus::Deprecated) {
             return Err(TemplateManagerError::TemplateUnavailable);
         }
@@ -167,16 +187,16 @@ impl<TAddr: NodeAddressable> TemplateManager<TAddr> {
                 TemplateExecutable::CompiledWasm(wasm) => {
                     let binary = fs::read(dbg_replacement).expect("Could not read debug file");
                     *wasm = binary;
-                }
+                },
                 TemplateExecutable::Flow(_) => {
                     todo!("debug replacements for flow templates not implemented");
-                }
+                },
                 _ => return Err(TemplateManagerError::TemplateUnavailable),
             }
 
-            Ok(result)
+            Ok(TemplateResult::Template(Box::new(result)))
         } else {
-            Ok(template.into())
+            Ok(TemplateResult::Template(Box::new(template.into())))
         }
     }
 
@@ -201,7 +221,10 @@ impl<TAddr: NodeAddressable> TemplateManager<TAddr> {
         let mut tx = self.global_db.create_transaction()?;
         let mut templates_db = self.global_db.templates(&mut tx);
         match templates_db.get_template(&template.template_address)? {
-            Some(_) => templates_db.update_template(&template.template_address, DbTemplateUpdate::status(TemplateStatus::Pending))?,
+            Some(_) => templates_db.update_template(
+                &template.template_address,
+                DbTemplateUpdate::status(TemplateStatus::Pending),
+            )?,
             None => templates_db.insert_template(template)?,
         }
 
@@ -236,22 +259,22 @@ impl<TAddr: NodeAddressable> TemplateManager<TAddr> {
                 template_hash = TemplateHash::Hash(template_hasher32().chain(binary.as_slice()).result());
                 compiled_code = Some(binary);
                 template_name = loaded_template.template_name().to_string();
-            }
+            },
             TemplateExecutable::Manifest(curr_manifest) => {
                 template_hash = TemplateHash::Hash(template_hasher32().chain(curr_manifest.as_str()).result());
                 manifest = Some(curr_manifest);
                 template_type = DbTemplateType::Manifest;
-            }
+            },
             TemplateExecutable::Flow(curr_flow_json) => {
                 template_hash = TemplateHash::Hash(template_hasher32().chain(curr_flow_json.as_str()).result());
                 flow_json = Some(curr_flow_json);
                 template_type = DbTemplateType::Flow;
-            }
+            },
             TemplateExecutable::DownloadableWasm(url, hash) => {
                 template_url = Some(url.to_string());
                 template_type = DbTemplateType::Wasm;
                 template_hash = TemplateHash::FixedHash(hash);
-            }
+            },
         }
 
         let template = DbTemplate {
@@ -326,25 +349,47 @@ impl<TAddr: NodeAddressable + Send + Sync + 'static> TemplateProvider for Templa
             return Ok(Some(template));
         }
 
-        let Some(template) = self.fetch_template(address).optional()? else {
+        let Some(template_result) = self.fetch_template(address).optional()? else {
             return Ok(None);
         };
+
         debug!(target: LOG_TARGET, "CACHE MISS: Template {}", address);
+
+        // getting template
+        let template = match template_result {
+            TemplateResult::Template(template) => template,
+            TemplateResult::PendingTemplate => {
+                let start = SystemTime::now();
+                let mut template = None;
+                while template.is_none() {
+                    let elapsed = start.duration_since(UNIX_EPOCH).expect("Time went backwards");
+                    if elapsed.gt(&self.config.pending_templates_wait_timeout()) {
+                        break;
+                    }
+                    if let Some(TemplateResult::Template(fetched_template)) = self.fetch_template(address).optional()? {
+                        template = Some(fetched_template);
+                    }
+                }
+                debug!(target: LOG_TARGET, "Failed to fetch template {} within {:?}", address, self.config.pending_templates_wait_timeout());
+                template.ok_or(Self::Error::TemplateUnavailable)?
+            },
+        };
+
         let loaded = match template.executable {
             TemplateExecutable::CompiledWasm(wasm) => {
                 let module = WasmModule::from_code(wasm);
                 module.load_template()?
-            }
+            },
             TemplateExecutable::Manifest(_) => return Err(TemplateManagerError::UnsupportedTemplateType),
             TemplateExecutable::Flow(flow_json) => {
                 let definition: FlowFunctionDefinition = serde_json::from_str(&flow_json)?;
                 let factory = FlowFactory::try_create::<Self>(definition)?;
                 LoadedTemplate::Flow(factory)
-            }
+            },
             TemplateExecutable::DownloadableWasm(_, _) => {
                 // impossible case, since there is no separate downloadable wasm type in DB level
                 return Err(Self::Error::UnsupportedTemplateType);
-            }
+            },
         };
 
         self.cache.insert(*address, loaded.clone());
diff --git a/applications/tari_dan_app_utilities/src/template_manager/implementation/mod.rs b/applications/tari_dan_app_utilities/src/template_manager/implementation/mod.rs
index bac7a4656..34e7de585 100644
--- a/applications/tari_dan_app_utilities/src/template_manager/implementation/mod.rs
+++ b/applications/tari_dan_app_utilities/src/template_manager/implementation/mod.rs
@@ -26,7 +26,8 @@ mod initializer;
 pub use initializer::spawn;
 
 mod manager;
-pub use manager::TemplateManager;
+pub use manager::{TemplateManager, TemplateResult};
+
 mod service;
 
 mod cmap_semaphore;
diff --git a/applications/tari_dan_app_utilities/src/template_manager/implementation/service.rs b/applications/tari_dan_app_utilities/src/template_manager/implementation/service.rs
index 10ea18b77..ae2dd8e57 100644
--- a/applications/tari_dan_app_utilities/src/template_manager/implementation/service.rs
+++ b/applications/tari_dan_app_utilities/src/template_manager/implementation/service.rs
@@ -26,7 +26,7 @@
 use std::{string::FromUtf8Error, sync::Arc};
 
 use log::*;
-use tari_common_types::types::PublicKey;
+use tari_common_types::types::{FixedHash, FixedHashSizeError, PublicKey};
 use tari_crypto::tari_utilities::{ByteArray, ByteArrayError};
 use tari_dan_common_types::{
     services::template_provider::TemplateProvider,
@@ -35,7 +35,7 @@ use tari_dan_common_types::{
     SubstateAddress,
     TemplateSyncRequest,
 };
-use tari_dan_engine::function_definitions::FlowFunctionDefinition;
+use tari_dan_engine::{function_definitions::FlowFunctionDefinition, wasm::WasmModule};
 use tari_dan_p2p::proto::{
     rpc as proto,
     rpc::{SyncTemplateResponse, TemplateType},
@@ -43,6 +43,7 @@ use tari_dan_p2p::proto::{
 use tari_dan_storage::global::{DbTemplateType, DbTemplateUpdate, TemplateStatus};
 use tari_engine_types::{
     calculate_template_binary_hash,
+    hashing::template_hasher32,
     published_template::PublishedTemplateAddress,
     substate::SubstateId,
 };
@@ -66,7 +67,10 @@ use super::{
     downloader::{DownloadRequest, DownloadResult},
     TemplateManager,
 };
-use crate::template_manager::interface::{TemplateExecutable, TemplateManagerError, TemplateManagerRequest};
+use crate::template_manager::{
+    implementation::manager::TemplateResult,
+    interface::{TemplateExecutable, TemplateManagerError, TemplateManagerRequest},
+};
 
 const LOG_TARGET: &str = "tari::template_manager";
 
@@ -86,6 +90,8 @@ pub enum TemplateManagerServiceError {
     ByteArray(ByteArrayError),
     #[error("UTF-8 bytes to string conversion error: {0}")]
     BytesUtf8Conversion(#[from] FromUtf8Error),
+    #[error("Fixed hash conversion error: {0}")]
+    FixedHashConversion(#[from] FixedHashSizeError),
 }
 
 pub struct TemplateManagerService<TAddr> {
@@ -119,8 +125,8 @@ impl<TAddr: NodeAddressable + 'static> TemplateManagerService<TAddr> {
                 rx_template_sync,
                 client_factory: Arc::new(client_factory),
             }
-                .run(shutdown)
-                .await?;
+            .run(shutdown)
+            .await?;
             Ok(())
         })
     }
@@ -181,9 +187,11 @@ impl<TAddr: NodeAddressable + 'static> TemplateManagerService<TAddr> {
 
         let template_address = req.address();
 
-        // TODO: check template status
-        // we have the template stored already, so no need to do anything with it
-        if self.manager.template_exists(&template_address)? {
+        // we have the template stored already as active, so no need to do anything with it
+        if self
+            .manager
+            .template_exists(&template_address, TemplateStatus::Active)?
+        {
             warn!(target: LOG_TARGET, "We have the template: {template_address}"); // TODO: remove, only for testing
             return Ok(());
         }
@@ -223,51 +231,54 @@ impl<TAddr: NodeAddressable + 'static> TemplateManagerService<TAddr> {
                         {
                             Ok(resp) => {
                                 // TODO: have a proof that this template was added before truly and validate here
-
-                                // TODO: continue
+                                let mut compiled_code = None;
+                                let mut flow_json = None;
+                                let mut manifest = None;
+                                let template_type: DbTemplateType;
+                                let bin_hash = FixedHash::from(
+                                    template_hasher32().chain(resp.binary.as_slice()).result().into_array(),
+                                );
+                                match resp.template_type() {
+                                    TemplateType::Wasm => {
+                                        compiled_code = Some(resp.binary);
+                                        template_type = DbTemplateType::Wasm;
+                                    },
+                                    TemplateType::Manifest => {
+                                        manifest = Some(String::from_utf8(resp.binary)?);
+                                        template_type = DbTemplateType::Manifest;
+                                    },
+                                    TemplateType::Flow => {
+                                        flow_json = Some(String::from_utf8(resp.binary)?);
+                                        template_type = DbTemplateType::Flow;
+                                    },
+                                }
                                 if let Err(error) = template_manager.update_template(
                                     template_address,
-                                    DbTemplateUpdate {
-                                        author_public_key: None,
-                                        expected_hash: None,
-                                        template_type: None,
-                                        compiled_code: None,
-                                        flow_json: None,
-                                        manifest: None,
-                                        status: None,
-                                    },
+                                    DbTemplateUpdate::template(
+                                        FixedHash::try_from(resp.author_public_key.to_vec())?,
+                                        Some(bin_hash),
+                                        resp.template_name,
+                                        template_type,
+                                        compiled_code,
+                                        flow_json,
+                                        manifest,
+                                    ),
                                 ) {
                                     error!(target: LOG_TARGET, "Failed to add new template: {error:?}");
                                     return Err(TemplateManagerServiceError::TemplateManager(error));
                                 }
-                                // if let Err(error) = template_manager.add_template(
-                                //     PublicKey::from_canonical_bytes(resp.author_public_key.as_slice())
-                                //         .map_err(TemplateManagerServiceError::ByteArray)?,
-                                //     template_address,
-                                //     match resp.template_type() {
-                                //         TemplateType::Wasm => TemplateExecutable::CompiledWasm(resp.binary),
-                                //         TemplateType::Manifest => {
-                                //             TemplateExecutable::Manifest(String::from_utf8(resp.binary)?)
-                                //         }
-                                //         TemplateType::Flow => TemplateExecutable::Flow(String::from_utf8(resp.binary)?),
-                                //     },
-                                //     None,
-                                //     Some(TemplateStatus::Active),
-                                // ) {
-                                //     error!(target: LOG_TARGET, "Failed to add new template: {error:?}");
-                                //     return Err(TemplateManagerServiceError::TemplateManager(error));
-                                // }
+
                                 warn!(target: LOG_TARGET, "✅ Template synced successfully: {}", template_address); // TODO: change to info!
                                 break;
-                            }
+                            },
                             Err(error) => {
                                 warn!(target: LOG_TARGET, "Failed to sync template from VN at address {:?}: {error:?}", addr);
-                            }
+                            },
                         }
-                    }
+                    },
                     Err(error) => {
                         warn!(target: LOG_TARGET, "Failed to obtain connection to VN at address {:?}: {error:?}", addr);
-                    }
+                    },
                 }
             }
 
@@ -302,10 +313,14 @@ impl<TAddr: NodeAddressable + 'static> TemplateManagerService<TAddr> {
                     self.handle_add_template(author_public_key, template_address, template, template_name)
                         .await,
                 );
-            }
-            GetTemplate { address, reply } => {
-                handle(reply, self.manager.fetch_template(&address));
-            }
+            },
+            GetTemplate { address, reply } => match self.manager.fetch_template(&address) {
+                Ok(result) => match result {
+                    TemplateResult::Template(template) => handle(reply, Ok(*template)),
+                    TemplateResult::PendingTemplate => handle(reply, Err(TemplateManagerError::TemplateUnavailable)),
+                },
+                Err(error) => handle(reply, Err(error)),
+            },
             GetTemplates { limit, reply } => handle(reply, self.manager.fetch_template_metadata(limit)),
             LoadTemplateAbi { address, reply } => handle(reply, self.handle_load_template_abi(address)),
         }
@@ -383,7 +398,7 @@ impl<TAddr: NodeAddressable + 'static> TemplateManagerService<TAddr> {
                                     target: LOG_TARGET,
                                     "⚠️ Template {} is not valid json: {}", download.template_address, e
                                 );
-                            }
+                            },
                         };
 
                         DbTemplateUpdate {
@@ -391,11 +406,11 @@ impl<TAddr: NodeAddressable + 'static> TemplateManagerService<TAddr> {
                             status: Some(status),
                             ..Default::default()
                         }
-                    }
+                    },
                     DbTemplateType::Manifest => todo!(),
                 };
                 self.manager.update_template(download.template_address, update)?;
-            }
+            },
             Err(err) => {
                 warn!(target: LOG_TARGET, "🚨 Failed to download template: {}", err);
                 self.manager
@@ -403,7 +418,7 @@ impl<TAddr: NodeAddressable + 'static> TemplateManagerService<TAddr> {
                         status: Some(TemplateStatus::DownloadFailed),
                         ..Default::default()
                     })?;
-            }
+            },
         }
         Ok(())
     }
diff --git a/applications/tari_dan_app_utilities/src/template_manager/implementation/template_config.rs b/applications/tari_dan_app_utilities/src/template_manager/implementation/template_config.rs
index bd49ca779..19ad042f5 100644
--- a/applications/tari_dan_app_utilities/src/template_manager/implementation/template_config.rs
+++ b/applications/tari_dan_app_utilities/src/template_manager/implementation/template_config.rs
@@ -20,7 +20,7 @@
 //  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 //  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-use std::{collections::HashMap, path::PathBuf};
+use std::{collections::HashMap, path::PathBuf, time::Duration};
 
 use serde::{Deserialize, Serialize};
 use tari_engine_types::TemplateAddress;
@@ -29,6 +29,7 @@ use tari_engine_types::TemplateAddress;
 pub struct TemplateConfig {
     max_cache_size_bytes: u64,
     debug_replacements: Vec<String>,
+    pending_templates_wait_timeout: Duration,
 }
 
 impl Default for TemplateConfig {
@@ -36,6 +37,7 @@ impl Default for TemplateConfig {
         Self {
             max_cache_size_bytes: 200 * 1024 * 1024,
             debug_replacements: Vec::new(),
+            pending_templates_wait_timeout: Duration::from_secs(30),
         }
     }
 }
@@ -54,4 +56,8 @@ impl TemplateConfig {
     pub fn max_cache_size_bytes(&self) -> u64 {
         self.max_cache_size_bytes
     }
+
+    pub fn pending_templates_wait_timeout(&self) -> Duration {
+        self.pending_templates_wait_timeout
+    }
 }
diff --git a/applications/tari_indexer/src/json_rpc/handlers.rs b/applications/tari_indexer/src/json_rpc/handlers.rs
index 3f0cfcf89..d5089e0ae 100644
--- a/applications/tari_indexer/src/json_rpc/handlers.rs
+++ b/applications/tari_indexer/src/json_rpc/handlers.rs
@@ -37,7 +37,10 @@ use tari_dan_app_utilities::{
     json_encoding::{encode_finalize_result_into_json, encode_finalized_result_into_json},
     keypair::RistrettoKeypair,
     substate_file_cache::SubstateFileCache,
-    template_manager::{implementation::TemplateManager, interface::TemplateExecutable},
+    template_manager::{
+        implementation::{TemplateManager, TemplateResult},
+        interface::{TemplateExecutable, TemplateManagerError},
+    },
 };
 use tari_dan_common_types::{optional::Optional, public_key_to_peer_id, PeerAddress};
 use tari_dan_engine::{template::TemplateModuleLoader, wasm::WasmModule};
@@ -578,10 +581,15 @@ impl JsonRpcHandlers {
     pub async fn get_template_definition(&self, value: JsonRpcExtractor) -> JrpcResult {
         let answer_id = value.get_answer_id();
         let request: GetTemplateDefinitionRequest = value.parse_params()?;
-        let template = self
+        let template_result = self
             .template_manager
             .fetch_template(&request.template_address)
             .map_err(|e| Self::internal_error(answer_id, e))?;
+        let TemplateResult::Template(template) = template_result else {
+            return Err(
+                Self::internal_error(answer_id, TemplateManagerError::TemplateUnavailable)
+            );
+        };
         let template = match template.executable {
             TemplateExecutable::CompiledWasm(code) => WasmModule::from_code(code)
                 .load_template()
diff --git a/applications/tari_validator_node/src/p2p/rpc/service_impl.rs b/applications/tari_validator_node/src/p2p/rpc/service_impl.rs
index cc4ff80b7..7ce4a592e 100644
--- a/applications/tari_validator_node/src/p2p/rpc/service_impl.rs
+++ b/applications/tari_validator_node/src/p2p/rpc/service_impl.rs
@@ -419,16 +419,19 @@ impl ValidatorNodeRpcService for ValidatorNodeRpcServiceImpl {
                     author_public_key: template.metadata.author_public_key.to_vec(),
                     binary,
                     template_type: TemplateType::Wasm.into(),
+                    template_name: template.metadata.name,
                 })),
                 TemplateExecutable::Manifest(manifest) => Ok(Response::new(SyncTemplateResponse {
                     author_public_key: template.metadata.author_public_key.to_vec(),
                     binary: manifest.into_bytes(),
                     template_type: TemplateType::Manifest.into(),
+                    template_name: template.metadata.name,
                 })),
                 TemplateExecutable::Flow(flow) => Ok(Response::new(SyncTemplateResponse {
                     author_public_key: template.metadata.author_public_key.to_vec(),
                     binary: flow.into_bytes(),
                     template_type: TemplateType::Flow.into(),
+                    template_name: template.metadata.name,
                 })),
                 // this case won't happen as there is no DB type for downloadable WASM
                 TemplateExecutable::DownloadableWasm(_, _) => Err(RpcStatus::not_implemented("Unsupported type!")),
diff --git a/dan_layer/p2p/proto/rpc.proto b/dan_layer/p2p/proto/rpc.proto
index 0d35a75a5..e975a3c87 100644
--- a/dan_layer/p2p/proto/rpc.proto
+++ b/dan_layer/p2p/proto/rpc.proto
@@ -274,5 +274,6 @@ message SyncTemplateRequest {
 message SyncTemplateResponse {
   bytes author_public_key = 1;
   TemplateType template_type = 2;
-  bytes binary = 3;
+  string template_name = 3;
+  bytes binary = 4;
 }
\ No newline at end of file
diff --git a/dan_layer/storage/src/global/backend_adapter.rs b/dan_layer/storage/src/global/backend_adapter.rs
index a1cae31ee..3dafc1b10 100644
--- a/dan_layer/storage/src/global/backend_adapter.rs
+++ b/dan_layer/storage/src/global/backend_adapter.rs
@@ -33,7 +33,7 @@ use tari_dan_common_types::{
     SubstateAddress,
 };
 
-use super::{DbBaseLayerBlockInfo, DbEpoch};
+use super::{DbBaseLayerBlockInfo, DbEpoch, TemplateStatus};
 use crate::{
     atomic::AtomicDb,
     global::{
@@ -59,7 +59,12 @@ pub trait GlobalDbAdapter: AtomicDb + Send + Sync + Clone {
         value: &T,
     ) -> Result<(), Self::Error>;
 
-    fn template_exists(&self, tx: &mut Self::DbTransaction<'_>, key: &[u8]) -> Result<bool, Self::Error>;
+    fn template_exists(
+        &self,
+        tx: &mut Self::DbTransaction<'_>,
+        key: &[u8],
+        status: TemplateStatus,
+    ) -> Result<bool, Self::Error>;
 
     fn get_template(&self, tx: &mut Self::DbTransaction<'_>, key: &[u8]) -> Result<Option<DbTemplate>, Self::Error>;
     fn get_templates(&self, tx: &mut Self::DbTransaction<'_>, limit: usize) -> Result<Vec<DbTemplate>, Self::Error>;
diff --git a/dan_layer/storage/src/global/template_db.rs b/dan_layer/storage/src/global/template_db.rs
index 1172d02f8..7412184fd 100644
--- a/dan_layer/storage/src/global/template_db.rs
+++ b/dan_layer/storage/src/global/template_db.rs
@@ -58,8 +58,8 @@ impl<'a, 'tx, TGlobalDbAdapter: GlobalDbAdapter> TemplateDb<'a, 'tx, TGlobalDbAd
         self.backend.update_template(self.tx, key, update)
     }
 
-    pub fn template_exists(&mut self, key: &[u8]) -> Result<bool, TGlobalDbAdapter::Error> {
-        self.backend.template_exists(self.tx, key)
+    pub fn template_exists(&mut self, key: &[u8], status: TemplateStatus) -> Result<bool, TGlobalDbAdapter::Error> {
+        self.backend.template_exists(self.tx, key, status)
     }
 }
 
@@ -100,6 +100,7 @@ impl DbTemplate {
 pub struct DbTemplateUpdate {
     pub author_public_key: Option<FixedHash>,
     pub expected_hash: Option<FixedHash>,
+    pub template_name: Option<String>,
     pub template_type: Option<DbTemplateType>,
     pub compiled_code: Option<Vec<u8>>,
     pub flow_json: Option<String>,
@@ -112,6 +113,7 @@ impl DbTemplateUpdate {
         Self {
             author_public_key: None,
             expected_hash: None,
+            template_name: None,
             template_type: None,
             compiled_code: None,
             flow_json: None,
@@ -120,22 +122,24 @@ impl DbTemplateUpdate {
         }
     }
 
-    // TODO: continue
     pub fn template(
         author_public_key: FixedHash,
+        expected_hash: Option<FixedHash>,
+        template_name: String,
         template_type: DbTemplateType,
         compiled_code: Option<Vec<u8>>,
         flow_json: Option<String>,
         manifest: Option<String>,
     ) -> Self {
         Self {
-            author_public_key: None,
-            expected_hash: None,
-            template_type: None,
-            compiled_code: None,
-            flow_json: None,
-            manifest: None,
-            status: Some(status),
+            author_public_key: Some(author_public_key),
+            expected_hash,
+            template_name: Some(template_name),
+            template_type: Some(template_type),
+            compiled_code,
+            flow_json,
+            manifest,
+            status: Some(TemplateStatus::Active),
         }
     }
 }
diff --git a/dan_layer/storage_sqlite/src/global/backend_adapter.rs b/dan_layer/storage_sqlite/src/global/backend_adapter.rs
index 7fc27c69a..9fb54945e 100644
--- a/dan_layer/storage_sqlite/src/global/backend_adapter.rs
+++ b/dan_layer/storage_sqlite/src/global/backend_adapter.rs
@@ -30,9 +30,10 @@ use std::{
 
 use diesel::{
     sql_query,
-    sql_types::{BigInt, Bigint},
+    sql_types::{BigInt, Bigint, Text},
     BoolExpressionMethods,
     ExpressionMethods,
+    IntoSql,
     JoinOnDsl,
     OptionalExtension,
     QueryDsl,
@@ -69,7 +70,6 @@ use tari_engine_types::TemplateAddress;
 use tari_utilities::ByteArray;
 
 use super::{models, models::DbValidatorNode};
-use crate::global::schema::templates::template_type;
 use crate::{
     error::SqliteStorageError,
     global::{
@@ -82,7 +82,7 @@ use crate::{
             TemplateModel,
             TemplateUpdateModel,
         },
-        schema::templates,
+        schema::{templates, templates::template_type},
         serialization::serialize_json,
     },
     SqliteTransaction,
@@ -338,6 +338,7 @@ impl<TAddr: NodeAddressable> GlobalDbAdapter for SqliteGlobalDbAdapter<TAddr> {
             author_public_key: template.author_public_key.map(|hash| hash.to_vec()),
             expected_hash: template.expected_hash.map(|hash| hash.to_vec()),
             template_type: template.template_type.map(|tmpl_type| tmpl_type.as_str().to_string()),
+            template_name: template.template_name,
             compiled_code: template.compiled_code,
             flow_json: template.flow_json,
             manifest: template.manifest,
@@ -355,10 +356,16 @@ impl<TAddr: NodeAddressable> GlobalDbAdapter for SqliteGlobalDbAdapter<TAddr> {
         Ok(())
     }
 
-    fn template_exists(&self, tx: &mut Self::DbTransaction<'_>, key: &[u8]) -> Result<bool, Self::Error> {
+    fn template_exists(
+        &self,
+        tx: &mut Self::DbTransaction<'_>,
+        key: &[u8],
+        status: TemplateStatus,
+    ) -> Result<bool, Self::Error> {
         use crate::global::schema::templates::dsl;
-        let result = dsl::templates
+        let mut result = dsl::templates
             .filter(templates::template_address.eq(key))
+            .filter(templates::status.eq(status.as_str()))
             .count()
             .limit(1)
             .get_result::<i64>(tx.connection())
@@ -471,13 +478,13 @@ impl<TAddr: NodeAddressable> GlobalDbAdapter for SqliteGlobalDbAdapter<TAddr> {
             "SELECT COUNT(distinct public_key) as cnt FROM validator_nodes WHERE start_epoch <= ? AND (end_epoch IS \
              NULL OR end_epoch > ?)",
         )
-            .bind::<BigInt, _>(epoch.as_u64() as i64)
-            .bind::<BigInt, _>(epoch.as_u64() as i64)
-            .get_result::<Count>(tx.connection())
-            .map_err(|source| SqliteStorageError::DieselError {
-                source,
-                operation: "count_validator_nodes".to_string(),
-            })?;
+        .bind::<BigInt, _>(epoch.as_u64() as i64)
+        .bind::<BigInt, _>(epoch.as_u64() as i64)
+        .get_result::<Count>(tx.connection())
+        .map_err(|source| SqliteStorageError::DieselError {
+            source,
+            operation: "count_validator_nodes".to_string(),
+        })?;
 
         Ok(count.cnt as u64)
     }
diff --git a/dan_layer/storage_sqlite/src/global/models/template.rs b/dan_layer/storage_sqlite/src/global/models/template.rs
index b1fe37b1e..aa3562620 100644
--- a/dan_layer/storage_sqlite/src/global/models/template.rs
+++ b/dan_layer/storage_sqlite/src/global/models/template.rs
@@ -61,6 +61,7 @@ pub struct TemplateUpdateModel {
     pub author_public_key: Option<Vec<u8>>,
     pub expected_hash: Option<Vec<u8>>,
     pub template_type: Option<String>,
+    pub template_name: Option<String>,
     pub compiled_code: Option<Vec<u8>>,
     pub flow_json: Option<String>,
     pub manifest: Option<String>,