diff --git a/pom.xml b/pom.xml
index 8f36ce0..7fe7189 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
   <groupId>com.blazemeter</groupId>
   <artifactId>jmeter-bzm-correlation-recorder</artifactId>
   <packaging>jar</packaging>
-  <version>2.1</version>
+  <version>2.2</version>
   <name>Correlation Recorder as JMeter plugin</name>
   <description>Correlation Recorder Plugin for JMeter</description>
   <url>https://github.com/Blazemeter/CorrelationRecorder</url>
@@ -160,6 +160,17 @@
       <version>1.9</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-artifact</artifactId>
+      <version>3.8.4</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.commons</groupId>
+      <artifactId>commons-lang3</artifactId>
+      <version>3.12.0</version>
+      <scope>provided</scope>
+    </dependency>
   </dependencies>
 
   <build>
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/CorrelationProxyControl.java b/src/main/java/com/blazemeter/jmeter/correlation/CorrelationProxyControl.java
index bb4837e..9e7c7d3 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/CorrelationProxyControl.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/CorrelationProxyControl.java
@@ -18,13 +18,11 @@
 import com.blazemeter.jmeter.correlation.core.templates.ConfigurationException;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplateDependency;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplateVersions;
-import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRegistry;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRegistryHandler;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepositoriesConfiguration;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepositoriesRegistryHandler;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepository;
 import com.blazemeter.jmeter.correlation.core.templates.LocalConfiguration;
-import com.blazemeter.jmeter.correlation.core.templates.LocalCorrelationTemplatesRegistry;
 import com.blazemeter.jmeter.correlation.core.templates.Template;
 import com.blazemeter.jmeter.correlation.core.templates.Template.Builder;
 import com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryManager;
@@ -115,7 +113,6 @@ public class CorrelationProxyControl extends ProxyControl implements
   private transient CorrelationTemplatesRepositoriesConfiguration templateRepositoryConfig;
   private transient LocalConfiguration localConfiguration;
   private transient CorrelationEngine correlationEngine;
-  private transient CorrelationTemplatesRegistry correlationTemplatesRegistry;
   private JMeterTreeNode target = null;
   private List<SampleResult> samples = new ArrayList<>();
   private Method putSamplesIntoModel;
@@ -136,7 +133,6 @@ public CorrelationProxyControl() {
     correlationEngine = new CorrelationEngine();
     componentsRegistry = CorrelationComponentsRegistry.getInstance();
     localConfiguration = new LocalConfiguration(JMeterUtils.getJMeterBinDir());
-    correlationTemplatesRegistry = new LocalCorrelationTemplatesRegistry(localConfiguration);
     templateRepositoryConfig =
         new CorrelationTemplatesRepositoriesConfiguration(localConfiguration);
     setName(RECORDER_NAME);
@@ -147,14 +143,12 @@ public CorrelationProxyControl(
       CorrelationComponentsRegistry componentsRegistry,
       CorrelationTemplatesRepositoriesConfiguration templateRepositoryConfig,
       LocalConfiguration localConfiguration,
-      CorrelationEngine correlationEngine,
-      CorrelationTemplatesRegistry correlationTemplatesRegistry) {
+      CorrelationEngine correlationEngine) {
     this.componentsRegistry = componentsRegistry;
     this.templateRepositoryConfig =
         templateRepositoryConfig;
     this.localConfiguration = localConfiguration;
     this.correlationEngine = correlationEngine;
-    this.correlationTemplatesRegistry = correlationTemplatesRegistry;
   }
 
   public CorrelationTemplatesRepositoriesConfiguration getTemplateRepositoryConfig() {
@@ -519,9 +513,7 @@ public void onSaveTemplate(Builder builder) throws IOException, ConfigurationExc
         .withResponseFilters(getResponseFilter())
         .build();
 
-    correlationTemplatesRegistry.save(template);
-    updateLocalRepository(template);
-    installTemplate(template.getRepositoryId(), template.getId(), template.getVersion());
+    localConfiguration.saveTemplate(template);
   }
 
   public List<RulesGroup> getGroups() {
@@ -578,16 +570,12 @@ public void setResponseFilter(String responseFilter) {
     setProperty(RESPONSE_FILTER, responseFilter);
   }
 
-  private void updateLocalRepository(Template template) {
-    templateRepositoryConfig
-        .updateLocalRepository(template.getId(), template.getVersion());
-  }
-
   @Override
   public void onLoadTemplate(String repositoryOwner, String id, String templateVersion)
       throws IOException {
-    Optional<Template> correlationTemplate = correlationTemplatesRegistry
-        .findByID(repositoryOwner, id, templateVersion);
+
+    Optional<Template> correlationTemplate = localConfiguration
+        .findById(repositoryOwner, id, templateVersion);
     if (correlationTemplate.isPresent()) {
       Template template = correlationTemplate.get();
 
@@ -658,24 +646,12 @@ private String cleanRepeated(String actual, String loaded) {
     return cleaned.stream().map(String::trim).collect(Collectors.joining(","));
   }
 
-  private List<CorrelationRule> appendCorrelationRules(List<CorrelationRule> actualRules,
-                                                       List<CorrelationRule> loadedRules) {
-    if (loadedRules.isEmpty()) {
-      return actualRules;
-    }
-
-    LinkedHashSet<CorrelationRule> actualRulesSet = new LinkedHashSet<>(actualRules);
-    actualRulesSet.addAll(loadedRules);
-
-    return new ArrayList<>(actualRulesSet);
-  }
-
   public String getContentTypeInclude() {
     return getPropertyAsString(RESPONSE_FILTER);
   }
 
   public List<Template> getInstalledCorrelationTemplates() {
-    return correlationTemplatesRegistry.getInstalledTemplates();
+    return localConfiguration.getInstalledTemplates();
   }
 
   public void update(String correlationComponents, List<RulesGroup> groups, String responseFilter,
@@ -688,7 +664,7 @@ public void update(String correlationComponents, List<RulesGroup> groups, String
 
   @Override
   public void saveRepository(String id, String url) throws IOException {
-    templateRepositoryConfig.save(id, url);
+    templateRepositoryConfig.saveRepository(id, url);
   }
 
   @Override
@@ -723,13 +699,13 @@ public Map<String, CorrelationTemplateVersions> getCorrelationTemplateVersionsBy
   @Override
   public void installTemplate(String repositoryName, String id, String version)
       throws ConfigurationException {
-    templateRepositoryConfig.installTemplate(repositoryName, id, version);
+    localConfiguration.installTemplate(repositoryName, id, version);
   }
 
   @Override
   public void uninstallTemplate(String repositoryName, String id, String version)
       throws ConfigurationException {
-    templateRepositoryConfig.uninstallTemplate(repositoryName, id, version);
+    localConfiguration.uninstallTemplate(repositoryName, id, version);
   }
 
   @Override
@@ -739,12 +715,12 @@ public String getRepositoryURL(String otherName) {
 
   @Override
   public RepositoryManager getRepositoryManager(String name) {
-    return templateRepositoryConfig.getRepositoryManager(name);
+    return localConfiguration.getRepositoryManager(name);
   }
 
   @Override
   public RepositoryManager getRepositoryManager(String name, String url) {
-    return templateRepositoryConfig.getRepositoryManager(name, url);
+    return localConfiguration.getRepositoryManager(name, url);
   }
 
   @Override
@@ -784,8 +760,8 @@ public List<String> checkURL(String id, String url) {
   public boolean refreshRepositories(String localConfigurationRoute,
                                      Consumer<Integer> setProgressConsumer,
                                      Consumer<String> setStatusConsumer) {
-    return templateRepositoryConfig
-        .refreshRepositories(localConfigurationRoute, setProgressConsumer, setStatusConsumer);
+    return localConfiguration.refreshRepositories(localConfigurationRoute, setProgressConsumer,
+        setStatusConsumer);
   }
 
   @Override
@@ -852,7 +828,6 @@ private void readObject(ObjectInputStream inputStream)
     correlationEngine = new CorrelationEngine();
     componentsRegistry = CorrelationComponentsRegistry.getInstance();
     localConfiguration = new LocalConfiguration(getTemplateDirectoryPath());
-    correlationTemplatesRegistry = new LocalCorrelationTemplatesRegistry(localConfiguration);
     templateRepositoryConfig =
         new CorrelationTemplatesRepositoriesConfiguration(localConfiguration);
     setName(RECORDER_NAME);
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlGui.java b/src/main/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlGui.java
index 5e7a02e..17c9fad 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlGui.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlGui.java
@@ -51,7 +51,7 @@ public class CorrelationProxyControlGui extends ProxyControlGui
   private CorrelationWizard wizard;
 
   static {
-    LocalConfiguration.installDefaultFiles();
+    LocalConfiguration.installDefaultFiles(JMeterUtils.getJMeterBinDir());
   }
 
   public CorrelationProxyControlGui() {
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplateVersions.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplateVersions.java
index eea6373..f1d8bf5 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplateVersions.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplateVersions.java
@@ -4,14 +4,25 @@
 import java.util.List;
 import java.util.Objects;
 
+/**
+ * This class represents a list of versions for a specific template.
+ * For example, if we have a template for "WordPress" with versions 1.0 and 1.1,
+ * this class will have name="WordPress" and versions=[1.0, 1.1]
+ */
 public class CorrelationTemplateVersions {
 
   private final List<String> versions = new ArrayList<>();
   private transient String name;
+  private String repositoryDisplayName;
 
   //Constructor added to avoid issues with the serialization
   public CorrelationTemplateVersions() {
+    this.repositoryDisplayName = "";
+  }
 
+  public CorrelationTemplateVersions(String name, List<String> versions) {
+    this.name = name;
+    this.versions.addAll(versions);
   }
 
   public CorrelationTemplateVersions(String version) {
@@ -34,9 +45,17 @@ public void addVersion(String version) {
     versions.add(version);
   }
 
+  public String getRepositoryDisplayName() {
+    return repositoryDisplayName;
+  }
+
+  public void setRepositoryDisplayName(String repositoryDisplayName) {
+    this.repositoryDisplayName = repositoryDisplayName;
+  }
+
   @Override
   public String toString() {
-    return "CorrelationTemplateReference{" +
+    return "CorrelationTemplateVersions {" +
         "versions=" + versions +
         '}';
   }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRegistry.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRegistry.java
index e660019..05da940 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRegistry.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRegistry.java
@@ -1,15 +1,5 @@
 package com.blazemeter.jmeter.correlation.core.templates;
 
-import java.io.IOException;
-import java.util.List;
-import java.util.Optional;
-
 public interface CorrelationTemplatesRegistry {
 
-  void save(Template template) throws IOException;
-
-  Optional<Template> findByID(String repositoryOwner, String id,
-                              String templateVersion) throws IOException;
-
-  List<Template> getInstalledTemplates();
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepositoriesConfiguration.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepositoriesConfiguration.java
index 951bfeb..0300e2a 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepositoriesConfiguration.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepositoriesConfiguration.java
@@ -1,21 +1,12 @@
 package com.blazemeter.jmeter.correlation.core.templates;
 
 import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.LOCAL_REPOSITORY_NAME;
-import static com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryUtils.getRepositoryFileName;
-import static com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryUtils.isURL;
 
 import com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryManager;
 import com.blazemeter.jmeter.correlation.core.templates.repository.TemplateProperties;
-import java.io.FileInputStream;
 import java.io.IOException;
-import java.io.InputStream;
-import java.net.URL;
-import java.util.AbstractMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Consumer;
-import org.apache.commons.codec.digest.DigestUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -33,22 +24,23 @@ public String getLocalRootFolder() {
     return localConfig.getRootFolder();
   }
 
-  public static InputStream getInputStream(String path) throws IOException {
-    return isURL(path) ? new URL(path).openStream() : new FileInputStream(path.replace("file://",
-        ""));
-  }
-
   public RepositoryManager getRepositoryManager(String name) {
     return localConfig.getRepositoryManager(name);
   }
 
   public RepositoryManager getRepositoryManager(String name, String url) {
-    return localConfig.getRepositoryManager(name, url);
+    RepositoryManager manager = localConfig.getRepositoryManager(name, url);
+    if (manager == null) {
+      manager = localConfig.getRepositoryManagerFromFolderOrUrl(name, url);
+    }
+    return manager;
   }
 
+  /*
   public void save(String name, String url) throws IOException {
     getTemplateRegistry(name, url).save(name, url);
   }
+  */
 
   private CorrelationTemplatesRepositoriesRegistry getTemplateRegistry(String name) {
     return ((CorrelationTemplatesRepositoriesRegistry) localConfig.getRepositoryManager(name)
@@ -56,8 +48,14 @@ private CorrelationTemplatesRepositoriesRegistry getTemplateRegistry(String name
   }
 
   private CorrelationTemplatesRepositoriesRegistry getTemplateRegistry(String name, String url) {
-    return ((CorrelationTemplatesRepositoriesRegistry) localConfig.getRepositoryManager(name, url)
-        .getTemplateRegistry());
+    RepositoryManager manager = getRepositoryManager(name, url);
+    return (CorrelationTemplatesRepositoriesRegistry) manager.getTemplateRegistry();
+  }
+
+  public void saveRepository(String name, String url) throws IOException {
+    RepositoryManager manager = getRepositoryManager(name, url);
+    ((CorrelationTemplatesRepositoriesRegistry) manager.getTemplateRegistry()).save(name, url);
+    localConfig.addRepositoryManager(manager);
   }
 
   public void deleteRepository(String name) throws IOException {
@@ -65,7 +63,7 @@ public void deleteRepository(String name) throws IOException {
   }
 
   public List<CorrelationTemplatesRepository> getCorrelationRepositories() {
-    return getTemplateRegistry(LOCAL_REPOSITORY_NAME).getRepositories();
+    return localConfig.getRepositories();
   }
 
   public Map<String, CorrelationTemplateVersions> getCorrelationTemplateVersionsByRepositoryName(
@@ -85,115 +83,24 @@ public Map<String, CorrelationTemplateVersions> getCorrelationTemplateVersionsBy
 
   public void installTemplate(String repositoryName, String templateName, String version)
       throws ConfigurationException {
-    getTemplateRegistry(LOCAL_REPOSITORY_NAME).installTemplate(repositoryName, templateName,
+    localConfig.installTemplate(repositoryName, templateName,
         version);
   }
 
   public void uninstallTemplate(String repositoryName, String name, String version)
       throws ConfigurationException {
-    getTemplateRegistry(LOCAL_REPOSITORY_NAME).uninstallTemplate(repositoryName, name, version);
+    localConfig.uninstallTemplate(repositoryName, name, version);
   }
 
   public String getRepositoryURL(String name) {
     return getTemplateRegistry(LOCAL_REPOSITORY_NAME).getRepositoryURL(name);
   }
 
-  public void updateLocalRepository(String templateId, String templateVersion) {
-    getTemplateRegistry(LOCAL_REPOSITORY_NAME).updateLocalRepository(templateId, templateVersion);
-  }
-
   public boolean isLocalTemplateVersionSaved(String templateId, String templateVersion) {
     return getTemplateRegistry(LOCAL_REPOSITORY_NAME).isLocalTemplateVersionSaved(templateId,
         templateVersion);
   }
 
-  public boolean refreshRepositories(String configurationRoute,
-                                     Consumer<Integer> setProgressConsumer,
-                                     Consumer<String> setStatusConsumer) {
-    int progress = 0;
-    boolean isUpToDate = true;
-    String correlationTemplateInstallationPath = configurationRoute +
-        LocalConfiguration.CORRELATIONS_TEMPLATE_INSTALLATION_FOLDER;
-
-    setProgressConsumer.accept(progress);
-
-    AbstractMap<String, RepositoryManager> repositoriesManagers =
-        localConfig.getRepositoriesManagers();
-
-    List<CorrelationTemplatesRepository> repositories = getCorrelationRepositories();
-
-    int total = 0;
-
-    Iterator<String> managersIterator = repositoriesManagers.keySet().iterator();
-    int progressAdvance = 0;
-    while (managersIterator.hasNext()) {
-      progressAdvance += 1;
-
-      // Recalculate, can increase dynamically on each iteration
-      total = repositoriesManagers.size() + repositories.size();
-
-      progress = (progressAdvance * 100) / total;
-
-      String managerId = managersIterator.next();
-      RepositoryManager manager = repositoriesManagers.get(managerId);
-      try {
-        setStatusConsumer.accept("Checking " + manager.getName() + "...");
-        setProgressConsumer.accept(progress);
-
-        manager.setup();
-      } catch (Exception e) {
-        LOG.error("Unknown Exception setting up {} with implementation:{}",
-            managerId, manager.getClass().getName(), e);
-      }
-    }
-
-    // After setup, update the list of repositories and the total
-    repositories = getCorrelationRepositories();
-    total = repositoriesManagers.size() + repositories.size();
-
-    for (CorrelationTemplatesRepository repo : repositories) {
-      progressAdvance += 1;
-      progress = (progressAdvance * 100) / total;
-      setStatusConsumer.accept("Updating " + repo.getName() + "...");
-      setProgressConsumer.accept(progress);
-
-      String url = getRepositoryURL(repo.getName());
-      String localFilePath =
-          correlationTemplateInstallationPath + repo.getName()
-              + "/" + getRepositoryFileName(repo.getName());
-
-      // Exclude if is Local
-      if (repo.getName().equals(LOCAL_REPOSITORY_NAME)) {
-        continue;
-      }
-
-      try {
-        RepositoryManager repManager = localConfig.getRepositoryManager(repo.getName(), url);
-        if (repManager.getRepository() == null) {
-          if (DigestUtils.md5Hex(getInputStream(url))
-              .equals(DigestUtils.md5Hex(getInputStream(localFilePath)))) {
-            continue;
-          }
-        } else {
-          // Compute the difference with the object
-          if (DigestUtils.md5Hex(localConfig.getValueAsBytes(repManager.getTemplateVersions()))
-              .equals(DigestUtils.md5Hex(getInputStream(localFilePath)))) {
-            continue;
-          }
-        }
-        save(repo.getName(), url);
-        isUpToDate = false;
-      } catch (IOException e) {
-        LOG.error("Error while comparing MD5 url: {} localPath: {} ", url, localFilePath, e);
-      }
-    }
-    progress = 100;
-    setStatusConsumer.accept("Update finished");
-    setProgressConsumer.accept(progress);
-
-    return isUpToDate;
-  }
-
   public Map<Template, TemplateProperties> getCorrelationTemplatesAndPropertiesByRepositoryName(
       String name,
       boolean useLocal) {
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepositoriesRegistry.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepositoriesRegistry.java
index 081c121..532adc7 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepositoriesRegistry.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepositoriesRegistry.java
@@ -13,25 +13,17 @@ public interface CorrelationTemplatesRepositoriesRegistry {
 
   CorrelationTemplatesRepository find(String id);
 
-  List<CorrelationTemplatesRepository> getRepositories();
-
   Map<String, CorrelationTemplateVersions> getCorrelationTemplateVersionsByRepositoryId(
       String name);
 
-  void installTemplate(String repositoryName, String templateName, String version)
-      throws ConfigurationException;
-
-  void uninstallTemplate(String repositoryName, String name, String version)
-      throws ConfigurationException;
-
   String getRepositoryURL(String name);
 
-  void updateLocalRepository(String templateId, String templateVersion);
-
   boolean isLocalTemplateVersionSaved(String templateId, String templateVersion);
 
   Map<Template, TemplateProperties> getCorrelationTemplatesAndPropertiesByRepositoryId(String name);
 
   Map<Template, TemplateProperties> getCorrelationTemplatesAndPropertiesByRepositoryId(
       String name, List<TemplateVersion> filter);
+
+  void upload(String name, Template template) throws IOException;
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepository.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepository.java
index 91e9e1f..7d0a5c4 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepository.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/CorrelationTemplatesRepository.java
@@ -5,15 +5,26 @@
 import java.util.Map;
 import java.util.Objects;
 
+/**
+ * This class represents a Repository with all the Templates associated to it.
+ * For example, if we have a repository called "Local" with templates for "WordPress" and
+ * "Joomla", this class will have name="Local" and templates=[WordPress, Joomla], also
+ * each template will have a list of versions associated to them.
+ */
 public class CorrelationTemplatesRepository {
 
   private transient String name;
+  private String displayName;
   private Map<String, CorrelationTemplateVersions> templatesVersions = new HashMap<>();
 
   //Constructor added to avoid issues with the serialization
   public CorrelationTemplatesRepository() {
   }
 
+  public CorrelationTemplatesRepository(String name) {
+    this.name = name;
+  }
+
   public CorrelationTemplatesRepository(String name, Map<String, CorrelationTemplateVersions>
                                             templatesVersions) {
     this.name = name;
@@ -27,10 +38,16 @@ public void addTemplate(String name, String version) {
         templatesVersions.get(name).addVersion(version);
       }
     } else {
-      templatesVersions.put(name, new CorrelationTemplateVersions(version));
+      CorrelationTemplateVersions value = new CorrelationTemplateVersions(version);
+      value.setRepositoryDisplayName(displayName);
+      templatesVersions.put(name, value);
     }
   }
 
+  public void addTemplate(String name, CorrelationTemplateVersions versions) {
+    templatesVersions.put(name, versions);
+  }
+
   public Map<String, CorrelationTemplateVersions> getTemplates() {
     return templatesVersions;
   }
@@ -47,10 +64,19 @@ public void setName(String name) {
     this.name = name;
   }
 
+  public String getDisplayName() {
+    return displayName;
+  }
+
+  public void setDisplayName(String displayName) {
+    this.displayName = displayName;
+  }
+
   @Override
   public String toString() {
     return "CorrelationTemplatesRepository{" +
         "name='" + name + '\'' +
+        ", displayName='" + displayName + "'" +
         ", templatesVersions=" + templatesVersions +
         '}';
   }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalConfiguration.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalConfiguration.java
index ebefe3a..2be0e52 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalConfiguration.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalConfiguration.java
@@ -1,24 +1,34 @@
 package com.blazemeter.jmeter.correlation.core.templates;
 
+import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.BZM_CENTRAL_REPOSITORY_NAME;
+import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.CENTRAL_REPOSITORY_NAME;
 import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.JSON_FILE_EXTENSION;
+import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.LOCAL_REPOSITORY_NAME;
 import static com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryUtils.isURL;
+import static com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryUtils.removeRepositoryNameFromFile;
 
 import com.blazemeter.jmeter.correlation.core.templates.repository.PluggableRepository;
 import com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryManager;
+import com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryUtils;
+import com.blazemeter.jmeter.correlation.core.templates.repository.TemplateProperties;
 import com.blazemeter.jmeter.correlation.core.templates.repository.pluggable.RemoteFolderRepository;
 import com.blazemeter.jmeter.correlation.core.templates.repository.pluggable.RemoteUrlRepository;
 import com.blazemeter.jmeter.correlation.gui.TestPlanTemplatesRepository;
 import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectWriter;
 import com.fasterxml.jackson.databind.ser.FilterProvider;
 import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
+import java.awt.image.BufferedImage;
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Modifier;
 import java.net.HttpURLConnection;
@@ -33,8 +43,11 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
+import javax.imageio.ImageIO;
+import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.commons.io.FileUtils;
 import org.apache.jmeter.util.JMeterUtils;
 import org.apache.jorphan.reflect.ClassFinder;
@@ -42,14 +55,13 @@
 import org.slf4j.LoggerFactory;
 
 public class LocalConfiguration {
-
   public static final String CORRELATIONS_TEMPLATE_INSTALLATION_FOLDER = "/correlation-templates/";
   public static final String INSTALL = "install";
   public static final String UNINSTALL = "uninstall";
-  public static final String LOCAL_CONFIGURATION_FILE_NAME = "repositories";
-  protected static final String SIEBEL_CORRELATION_TEMPLATE = "siebel-1.0-template.json";
-  protected static final String JAR_FILE_SUFFIX = ".jar";
-  protected static final String TEMPLATES_FOLDER_PATH = "/templates/";
+  private static final String LOCAL_CONFIGURATION_FILE_NAME = "repositories";
+  private static final String SIEBEL_CORRELATION_TEMPLATE = "siebel-1.0-template.json";
+  private static final String JAR_FILE_SUFFIX = ".jar";
+  private static final String TEMPLATES_FOLDER_PATH = "/templates/";
   private static final String LOCAL_REPOSITORIES_MANAGERS_FILE_NAME = "managers";
   private static final String CORRELATION_RECORDER_TEST_PLAN = "correlation-recorder.jmx";
   private static final String CORRELATION_RECORDER_TEMPLATE_DESC = "correlation-recorder-template"
@@ -94,15 +106,15 @@ public LocalConfiguration(String jmeterRootFolder) {
     this(jmeterRootFolder, false);
   }
 
-  public static void installDefaultFiles() {
+  public static void installDefaultFiles(String rootFolder) {
     LOG.info("Installing default files");
-    installCorrelationRecorderTemplateTestPlan();
-    installSiebelCorrelationTemplate();
+    installCorrelationRecorderTemplateTestPlan(rootFolder);
+    installSiebelCorrelationTemplate(rootFolder);
   }
 
-  private static void installCorrelationRecorderTemplateTestPlan() {
+  private static void installCorrelationRecorderTemplateTestPlan(String rootFolder) {
     TestPlanTemplatesRepository templateRepository = new TestPlanTemplatesRepository(
-        Paths.get(JMeterUtils.getJMeterBinDir(), TEMPLATES_FOLDER_PATH).toAbsolutePath().toString()
+        Paths.get(rootFolder, TEMPLATES_FOLDER_PATH).toAbsolutePath().toString()
             + File.separator);
 
     templateRepository.addCorrelationRecorderTemplate(CORRELATION_RECORDER_TEST_PLAN,
@@ -112,9 +124,9 @@ private static void installCorrelationRecorderTemplateTestPlan() {
     LOG.info("bzm - Correlation Recorder Test Plan Template installed");
   }
 
-  private static void installSiebelCorrelationTemplate() {
+  private static void installSiebelCorrelationTemplate(String rootFolder) {
     TestPlanTemplatesRepository templateRepository = new TestPlanTemplatesRepository(Paths
-        .get(JMeterUtils.getJMeterBinDir(),
+        .get(rootFolder,
             LocalConfiguration.CORRELATIONS_TEMPLATE_INSTALLATION_FOLDER)
         .toAbsolutePath().toString() + File.separator);
     templateRepository.addCorrelationTemplate(SIEBEL_CORRELATION_TEMPLATE,
@@ -240,6 +252,7 @@ private void registerPreInstalledRepositories() throws IOException {
           try {
             repository.setConfig(this);
             repository.setName(key);
+            repository.setEndPoint(getRepositoryURL(key));
             repository.init();
             addRepository(repository.getName(), repository.getEndPoint());
             repositoriesManagers.put(repository.getName(), repository);
@@ -253,6 +266,19 @@ private void registerPreInstalledRepositories() throws IOException {
         }
       }
     });
+
+    // Find repositories without manager for standard Remote File or URL repositories
+    repositories.forEach(repo -> {
+      // When pre-registered repository don't have a Manager,try to assign one based on the URL
+      if (!repositoriesManagers.containsKey(repo.getName())) {
+        RepositoryManager repository =
+            getRepositoryManagerFromFolderOrUrl(repo.getName(), repo.getUrl());
+        if (repository != null) {
+          addRepositoryManager(repository);
+        }
+      }
+    });
+
     saveRepositoriesManagers();
   }
 
@@ -282,19 +308,6 @@ public AbstractMap<String, RepositoryManager> getRepositoriesManagers() {
   }
 
   public RepositoryManager getRepositoryManager(String name, String url) {
-    if (!repositoriesManagers.containsKey(name)) {
-
-      // Try to identify the manager based on the URL, for "Legacy" Repositories
-      RepositoryManager repository;
-      if (isURL(url)) {
-        repository = new RemoteUrlRepository(name, url);
-      } else {
-        repository = new RemoteFolderRepository(name, url);
-      }
-      repository.setConfig(this);
-      repository.init();
-      addRepositoryManager(repository);
-    }
     return repositoriesManagers.getOrDefault(name, null);
   }
 
@@ -306,7 +319,7 @@ public RepositoryManager getRepositoryManager(String name) {
     return repositoriesManagers.getOrDefault(name, null);
   }
 
-  private void createDefaultCorrelationTemplateFolder() {
+  public void createDefaultCorrelationTemplateFolder() {
     File directory = new File(rootFolder);
     if (!directory.exists() && directory.mkdir()) {
       LOG.debug("Created the root folder {}", rootFolder);
@@ -335,12 +348,7 @@ private void setJsonConfigurations() {
   }
 
   private void loadLocalConfigurationFile() {
-    File localConfigurationFile = new File(
-        Paths.get(
-                configurationFolder,
-                LOCAL_CONFIGURATION_FILE_NAME + JSON_FILE_EXTENSION)
-            .toAbsolutePath().toString()
-    );
+    File localConfigurationFile = new File(getConfigurationFilePath());
     if (localConfigurationFile.exists()) {
       try {
         repositories = readValue(localConfigurationFile, LocalConfiguration.class).repositories;
@@ -360,6 +368,19 @@ public <T> T readValue(String source, Class<T> valueType) throws IOException {
     return mapper.readValue(source, valueType);
   }
 
+  public Template readTemplateFromPath(String templatePath) throws IOException {
+    return readValue(new File(templatePath), Template.class);
+  }
+
+  public Template readTemplateFromString(String templateContent) throws IOException {
+    return readValue(templateContent, Template.class);
+  }
+
+  public TemplateProperties readTemplatePropertiesFromPath(String templatePropertiesPath)
+      throws IOException {
+    return readValue(new File(templatePropertiesPath), TemplateProperties.class);
+  }
+
   public Map<String, CorrelationTemplateVersions> readTemplatesReferences(File source)
       throws IOException {
     return mapper.readValue(source, new TypeReference<Map<String, CorrelationTemplateVersions>>() {
@@ -382,11 +403,7 @@ public void addRepository(String name, String url) {
   }
 
   public void saveLocalConfiguration() {
-    String localConfigurationPath =
-        Paths.get(
-            configurationFolder,
-            LOCAL_CONFIGURATION_FILE_NAME + JSON_FILE_EXTENSION
-        ).toAbsolutePath().toString();
+    String localConfigurationPath = getConfigurationFilePath();
 
     File localConfigurationFile = new File(localConfigurationPath);
 
@@ -401,6 +418,12 @@ public void saveLocalConfiguration() {
     }
   }
 
+  private String getConfigurationFilePath() {
+    return Paths.get(configurationFolder, LOCAL_CONFIGURATION_FILE_NAME + JSON_FILE_EXTENSION)
+        .toAbsolutePath()
+        .toString();
+  }
+
   public void removeRepository(String repositoryName) {
     findRepositoryById(repositoryName).ifPresent(r -> repositories.remove(r));
     saveLocalConfiguration();
@@ -430,16 +453,27 @@ public void manageTemplate(String action, String repositoryName, String template
     saveLocalConfiguration();
   }
 
-  public List<CorrelationTemplatesRepositoryConfiguration> getRepositories() {
-    return repositories;
-  }
-
   public List<String> getRepositoriesNames() {
     return repositories.stream()
         .map(CorrelationTemplatesRepositoryConfiguration::getName)
         .collect(Collectors.toList());
   }
 
+
+  /*
+   * Returns the list of Repository's ID with their display name
+   * */
+  public Map<String, String> getRepositoriesDisplayName() {
+    Map<String, String> repositoriesDisplayName = new HashMap<>();
+    for (CorrelationTemplatesRepositoryConfiguration repository : repositories) {
+      repositoriesDisplayName.put(repository.getName(), repository.getUrl());
+    }
+    repositoriesDisplayName.put(LOCAL_REPOSITORY_NAME, "Local");
+    repositoriesDisplayName.put(CENTRAL_REPOSITORY_NAME, "GitHub's Central");
+    repositoriesDisplayName.put(BZM_CENTRAL_REPOSITORY_NAME, "BlazeMeter's Central");
+    return repositoriesDisplayName;
+  }
+
   public boolean isInstalled(String repositoryName, String templateId) {
     return repositories.stream().anyMatch(
         r -> r.getName().equals(repositoryName) && r.getInstalledTemplates()
@@ -581,7 +615,382 @@ public List<String> checkRepositoryURL(String repositoryId, String repositoryURL
     List<String> errors = new ArrayList<>();
     if (repositoryManager != null) {
       errors.addAll(repositoryManager.checkRepositoryURL(repositoryURL));
+    } else {
+      repositoryManager = getRepositoryManagerFromFolderOrUrl(repositoryId, repositoryURL);
+      errors.addAll(repositoryManager.checkRepositoryURL(repositoryURL));
     }
     return errors;
   }
+
+  public RepositoryManager getRepositoryManagerFromFolderOrUrl(String repositoryId,
+                                                               String repositoryURL) {
+    RepositoryManager manager;
+    if (isURL(repositoryURL)) {
+      manager = new RemoteUrlRepository();
+    } else {
+      manager = new RemoteFolderRepository();
+    }
+    manager.setName(repositoryId);
+    manager.setEndPoint(repositoryURL);
+    manager.setConfig(this);
+    manager.init();
+    return manager;
+  }
+
+  public static String getTemplateFilename(Template template) {
+    return getTemplateFilename(template.getId(), template.getVersion());
+  }
+
+  public static String getTemplateFilename(String id, String version) {
+    return id + "-" + version + RepositoryGeneralConst.TEMPLATE_FILE_SUFFIX;
+  }
+
+  public static String getTemplateSnapshotFilename(String id, String version) {
+    return id + "-" + version + RepositoryGeneralConst.SNAPSHOT_FILE_SUFFIX;
+  }
+
+  public static String getTemplatePropertiesFilename(String id, String version) {
+    return id + "-" + version + RepositoryGeneralConst.PROPERTIES_FILE_SUFFIX;
+  }
+
+  public File getRepositoryFolder(String repositoryName) {
+    return new File(getRepositoryFolderPath(repositoryName));
+  }
+
+  public String getRepositoryFolderPath(String repositoryName) {
+    String repositoryFolderPath = getRepositoryFolderName(repositoryName);
+    return Paths.get(getCorrelationsTemplateInstallationFolder(), repositoryFolderPath)
+        .toAbsolutePath() + File.separator;
+  }
+
+  public String getRepositoryFolderName(String name) {
+    return name.equals(LOCAL_REPOSITORY_NAME) ? "" : name + File.separator;
+  }
+
+  public String getRepositoryFilePath(String repositoryName) {
+    return Paths.get(getRepositoryFolderPath(repositoryName),
+            RepositoryUtils.getRepositoryFileName(repositoryName))
+        .toAbsolutePath()
+        .toString();
+  }
+
+  public File getRepositoryFile(String repositoryName) {
+    return new File(getRepositoryFilePath(repositoryName));
+  }
+
+  public String getTemplateFilePath(String repositoryName, String templateId,
+                                    String templateVersion) {
+    return Paths.get(getRepositoryFolderPath(repositoryName),
+            getTemplateFilename(templateId, templateVersion))
+        .toAbsolutePath()
+        .toString();
+  }
+
+  public String getTemplateContentAsString(Template template) throws JsonProcessingException {
+    return mapper.writeValueAsString(template);
+  }
+
+  public String getTemplatePropertiesFromFilepath(File templateFile) {
+    return templateFile.getAbsolutePath()
+        .replace(RepositoryGeneralConst.TEMPLATE_FILE_SUFFIX,
+            RepositoryGeneralConst.PROPERTIES_FILE_SUFFIX);
+  }
+
+  public boolean isCloudStored(Template template) {
+    RepositoryManager manager = getRepositoryManager(template.getRepositoryId());
+    return isRemoteRepository(manager.getTemplateRegistry());
+  }
+
+  public boolean isRemoteRepository(Object templateRegistry) {
+    return templateRegistry instanceof RemoteCorrelationTemplatesRepositoriesRegistry;
+  }
+
+  public void triggerCloudUpload(Template template) throws IOException {
+    getRepositoryManager(template.getRepositoryId()).upload(template);
+  }
+
+  public Optional<Template> findById(String repository, String id, String version)
+      throws IOException {
+    String templateFilePath = getTemplateFilePath(repository, id, version);
+    Template template = readTemplateFromPath(templateFilePath);
+    template.setSnapshot(getSnapshot(template));
+    return Optional.ofNullable(template);
+  }
+
+  public BufferedImage getSnapshot(Template loadedTemplate) {
+    try {
+      File snapshotFile = getSnapshotFile(loadedTemplate);
+      if (!snapshotFile.exists()) {
+        loadedTemplate.setSnapshotPath("");
+        return null;
+      }
+
+      loadedTemplate.setSnapshotPath(snapshotFile.getAbsolutePath());
+      return ImageIO.read(snapshotFile);
+    } catch (IOException e) {
+      LOG.warn("There was an issue trying to retrieve the image for the template '{}'",
+          loadedTemplate.getId(), e);
+      return null;
+    }
+  }
+
+  public File getSnapshotFile(Template template) {
+    return new File(getRepositoryFolderPath(template.getRepositoryId()),
+        template.getSnapshotName());
+  }
+
+  public List<Template> getInstalledTemplates() {
+    ArrayList<Template> loadedTemplates = new ArrayList<>();
+    getRepositoriesWithInstalledTemplates()
+        .forEach(r -> r.getInstalledTemplates().forEach((template, version) -> {
+          String installedTemplateFile = getTemplateFilePath(r.getName(),
+              template, version);
+
+          try {
+            Template loadedTemplate = readTemplateFromPath(installedTemplateFile);
+            loadedTemplate.setRepositoryId(r.getName());
+            loadedTemplate.setSnapshot(getSnapshot(loadedTemplate));
+            loadedTemplates.add(loadedTemplate);
+          } catch (IOException e) {
+            LOG.warn("There was an error trying to get the CorrelationTemplate from the file {}",
+                installedTemplateFile, e);
+          }
+        }));
+
+    return loadedTemplates;
+  }
+
+  public void saveTemplate(Template template) throws IOException, ConfigurationException {
+    if (isCloudStored(template)) {
+      triggerCloudUpload(template);
+    } else {
+      writeFile(template);
+      saveSnapshot(template);
+      updateLocalRepository(template);
+      installTemplate(template.getRepositoryId(), template.getId(), template.getVersion());
+    }
+  }
+
+  private void writeFile(Template template) throws IOException {
+    writeValue(new File(getFileNameForTemplate(template)), template);
+  }
+
+  public String getFileNameForTemplate(Template template) {
+    return getTemplateFilePath(template.getRepositoryId(), template.getId(),
+        template.getVersion());
+  }
+
+  private void saveSnapshot(Template template) throws IOException {
+    File snapshotFile = getSnapshotFile(template);
+
+    if (template.getSnapshot() != null) {
+      writeValue(snapshotFile, template);
+      ImageIO.write(template.getSnapshot(), RepositoryGeneralConst.SNAPSHOT_FILE_TYPE,
+          snapshotFile);
+    }
+  }
+
+  private void updateLocalRepository(Template template) {
+    updateLocalRepository(template.getId(), template.getVersion());
+  }
+
+  public void updateLocalRepository(String templateId, String templateVersion) {
+    File localRepositoryFile = getRepositoryFile(LOCAL_REPOSITORY_NAME);
+    try {
+      CorrelationTemplatesRepository localRepository;
+
+      if (!localRepositoryFile.exists()) {
+        localRepositoryFile.createNewFile();
+        localRepository = new CorrelationTemplatesRepository();
+        localRepository.setTemplates(new HashMap<String, CorrelationTemplateVersions>() {
+        });
+        writeValue(localRepositoryFile, localRepository.getTemplates());
+        LOG.info("No local repository file found. Created a new one instead");
+      } else {
+        localRepository = new CorrelationTemplatesRepository("local",
+            readTemplatesVersions(localRepositoryFile));
+      }
+
+      localRepository.addTemplate(templateId, templateVersion);
+      writeValue(localRepositoryFile, localRepository.getTemplates());
+      addRepository(LOCAL_REPOSITORY_NAME, localRepositoryFile.getAbsolutePath());
+    } catch (IOException e) {
+      LOG.warn("There was a problem trying to update the local repository file.", e);
+    }
+  }
+
+  public void installTemplate(String repositoryName, String templateId, String templateVersion)
+      throws ConfigurationException {
+    File template = new File(getTemplateFilePath(repositoryName, templateId, templateVersion));
+    if (!template.exists()) {
+      LOG.error("The template {} doesn't exists", template.getName());
+      throw new ConfigurationException(
+          "The template " + template.getAbsolutePath() + " doesn't exists");
+    }
+
+    manageTemplate(LocalConfiguration.INSTALL, repositoryName, templateId, templateVersion);
+  }
+
+  public Map<String, CorrelationTemplateVersions> readTemplatesVersions(File source)
+      throws IOException {
+    return readTemplatesReferences(source);
+  }
+
+  public void uninstallTemplate(String repositoryName, String templateId, String templateVersion)
+      throws ConfigurationException {
+    manageTemplate(LocalConfiguration.UNINSTALL, repositoryName, templateId, templateVersion);
+  }
+
+  public boolean refreshRepositories(String configurationRoute,
+                                     Consumer<Integer> setProgressConsumer,
+                                     Consumer<String> setStatusConsumer) {
+    int progress = 0;
+    boolean isUpToDate = true;
+    setProgressConsumer.accept(progress);
+
+    AbstractMap<String, RepositoryManager> repositoriesManagers = getRepositoriesManagers();
+
+    List<CorrelationTemplatesRepository> repositories = getRepositories();
+    int total = 0;
+    Iterator<String> managersIterator = repositoriesManagers.keySet().iterator();
+    int progressAdvance = 0;
+    while (managersIterator.hasNext()) {
+      progressAdvance += 1;
+
+      // Recalculate, can increase dynamically on each iteration
+      total = repositoriesManagers.size() + repositories.size();
+
+      progress = (progressAdvance * 100) / total;
+
+      String managerId = managersIterator.next();
+      RepositoryManager manager = repositoriesManagers.get(managerId);
+      try {
+        String repositoryName = getRepositoryName(manager);
+        setStatusConsumer.accept("Syncing '" + repositoryName + "' repository.");
+        setProgressConsumer.accept(progress);
+
+        manager.setup();
+      } catch (Exception e) {
+        LOG.error("Unknown Exception setting up {} with implementation:{}",
+            managerId, manager.getClass().getName(), e);
+      }
+    }
+
+    // After setup, update the list of repositories and the total
+    repositories = getRepositories();
+    total = repositoriesManagers.size() + repositories.size();
+
+    for (CorrelationTemplatesRepository repo : repositories) {
+      progressAdvance += 1;
+      progress = (progressAdvance * 100) / total;
+
+      String repositoryDisplayName = getRepositoryName(repo);
+      setStatusConsumer.accept("Updating '" + repositoryDisplayName + "' repository.");
+      setProgressConsumer.accept(progress);
+
+      // Exclude if is Local
+      if (repo.getName().equals(LOCAL_REPOSITORY_NAME)) {
+        continue;
+      }
+
+      String url = getRepositoryURL(repo.getName());
+      String repositoryFilePath = getRepositoryFilePath(repo.getName());
+      try {
+        RepositoryManager repManager = getRepositoryManager(repo.getName(), url);
+        if (repManager == null) {
+          LOG.error("Internal error, repository without manager: {} ", repo.getName());
+          continue;
+        }
+        //TODO: We need to rework this part, it's not working properly
+        if (repManager.getRepository() == null) {
+          try {
+            if (DigestUtils.md5Hex(getInputStream(url))
+                .equals(DigestUtils.md5Hex(getInputStream(repositoryFilePath)))) {
+              continue;
+            }
+          } catch (IOException e) {
+            LOG.error("Error while comparing MD5 url: {} localPath: {} ", url, repositoryFilePath,
+                e);
+            isUpToDate = false;
+            continue;
+          }
+        } else {
+          // Compute the difference with the object
+          if (DigestUtils.md5Hex(getValueAsBytes(repManager.getTemplateVersions()))
+              .equals(DigestUtils.md5Hex(getInputStream(repositoryFilePath)))) {
+            continue;
+          }
+        }
+        save(repo.getName(), url);
+        isUpToDate = false;
+      } catch (IOException e) {
+        LOG.error("Error while comparing MD5 url: {} localPath: {} ", url, repositoryFilePath, e);
+      }
+    }
+    progress = 100;
+    setStatusConsumer.accept("Update finished");
+    setProgressConsumer.accept(progress);
+
+    return isUpToDate;
+  }
+
+  public List<CorrelationTemplatesRepository> getRepositories() {
+    List<CorrelationTemplatesRepository> correlationRepositoryList = new ArrayList<>();
+    List<String> repositoriesList = getRepositoriesNames();
+    // We force the update of the proper Repository Display Name
+    Map<String, String> repositoriesDisplayName = getRepositoriesDisplayName();
+
+    repositoriesList.forEach(r -> {
+      File repositoryFile = getRepositoryFile(r);
+      String repoName = removeRepositoryNameFromFile(repositoryFile.getName());
+      if (repositoryFile.exists()) {
+        try {
+          CorrelationTemplatesRepository loadedRepository =
+              new CorrelationTemplatesRepository(repoName, readTemplatesVersions(repositoryFile));
+
+          // refresh the version's protocol name (that currently is null)
+          Map<String, CorrelationTemplateVersions> templates = loadedRepository.getTemplates();
+          templates.forEach((key, value) -> value.setName(key));
+          loadedRepository.setDisplayName(repositoriesDisplayName.get(repoName));
+          correlationRepositoryList.add(loadedRepository);
+        } catch (IOException e) {
+          LOG.error("There was an issue trying to read the file {}.", repositoryFile.getName(), e);
+        }
+      } else {
+        LOG.warn("Repository file not found {}.", repositoryFile);
+      }
+    });
+
+    return correlationRepositoryList;
+  }
+
+  private static String getRepositoryName(RepositoryManager manager) {
+    String repositoryName = manager.getDisplayName();
+    if (repositoryName == null || repositoryName.isEmpty()) {
+      repositoryName = manager.getName();
+    }
+    return repositoryName;
+  }
+
+  private static String getRepositoryName(CorrelationTemplatesRepository repo) {
+    String repositoryDisplayName = repo.getDisplayName();
+    if (repositoryDisplayName == null || repositoryDisplayName.isEmpty()) {
+      repositoryDisplayName = repo.getName();
+    }
+    return repositoryDisplayName;
+  }
+
+  public static InputStream getInputStream(String path) throws IOException {
+    return isURL(path) ? new URL(path).openStream() : new FileInputStream(path.replace("file://",
+        ""));
+  }
+
+  public void save(String id, String url) throws IOException {
+    getTemplateRegistry(id, url).save(id, url);
+  }
+
+  private CorrelationTemplatesRepositoriesRegistry getTemplateRegistry(String name, String url) {
+    return ((CorrelationTemplatesRepositoriesRegistry) getRepositoryManager(name, url)
+        .getTemplateRegistry());
+  }
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRegistry.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRegistry.java
index 2d4eb32..c0669a9 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRegistry.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRegistry.java
@@ -1,123 +1,15 @@
 package com.blazemeter.jmeter.correlation.core.templates;
 
-import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.JSON_FILE_EXTENSION;
-import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.LOCAL_REPOSITORY_NAME;
-
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import javax.imageio.ImageIO;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class LocalCorrelationTemplatesRegistry implements CorrelationTemplatesRegistry {
-
-  public static final String SNAPSHOT_FILE_TYPE = "png";
   private static final Logger LOG = LoggerFactory
       .getLogger(LocalCorrelationTemplatesRegistry.class);
-  private static final String TEMPLATE_SUFFIX = "-template";
-  private static final String PROPERTIES_SUFFIX = "-properties";
-  public static final String TEMPLATE_FILE_SUFFIX = TEMPLATE_SUFFIX + JSON_FILE_EXTENSION;
-  public static final String PROPERTIES_FILE_SUFFIX = PROPERTIES_SUFFIX + JSON_FILE_EXTENSION;
-
   private final LocalConfiguration localConfiguration;
 
   public LocalCorrelationTemplatesRegistry(LocalConfiguration localConfiguration) {
     this.localConfiguration = localConfiguration;
   }
 
-  @Override
-  public void save(Template template) throws IOException {
-    saveTemplate(template);
-    saveSnapshot(template);
-  }
-
-  private String getFileForTemplate(String repository, String templateId, String version) {
-    return localConfiguration.getCorrelationsTemplateInstallationFolder()
-        + getRepositoryFolderName(repository) + templateId + "-"
-        + version
-        + TEMPLATE_FILE_SUFFIX;
-  }
-
-  private void saveTemplate(Template template) throws IOException {
-    localConfiguration
-        .writeValue(new File(getFileForTemplate(template.getRepositoryId(), template.getId(),
-            template.getVersion())), template);
-  }
-
-  private void saveSnapshot(Template template) throws IOException {
-    File snapshotFile = getSnapshotFile(template);
-
-    if (template.getSnapshot() != null) {
-      localConfiguration.writeValue(snapshotFile, template);
-      ImageIO.write(template.getSnapshot(), SNAPSHOT_FILE_TYPE,
-          snapshotFile);
-    }
-  }
-
-  private File getSnapshotFile(Template template) {
-    return new File(localConfiguration.getCorrelationsTemplateInstallationFolder()
-        + getRepositoryFolderName(template.getRepositoryId()),
-        template.getSnapshotName());
-  }
-
-  @Override
-  public Optional<Template> findByID(String repositoryOwner, String id,
-                                     String templateVersion)
-      throws IOException {
-    Template correlationTemplate = localConfiguration.readValue(
-        new File(getFileForTemplate(repositoryOwner, id, templateVersion)),
-        Template.class);
-    correlationTemplate.setSnapshot(getSnapshot(correlationTemplate));
-    return Optional.of(correlationTemplate);
-  }
-
-  private BufferedImage getSnapshot(Template loadedTemplate) {
-    try {
-      File snapshotFile = getSnapshotFile(loadedTemplate);
-      if (!snapshotFile.exists()) {
-        loadedTemplate.setSnapshotPath("");
-        LOG.warn("Couldn't find a snapshot file for the CorrelationTemplate {}.",
-            loadedTemplate.getId());
-        return null;
-      }
-
-      loadedTemplate.setSnapshotPath(snapshotFile.getAbsolutePath());
-      return ImageIO.read(snapshotFile);
-    } catch (IOException e) {
-      LOG.warn("There was an issue trying to retrieve the image for the template '{}'",
-          loadedTemplate.getId(), e);
-      return null;
-    }
-  }
-
-  private String getRepositoryFolderName(String name) {
-    return name.equals(LOCAL_REPOSITORY_NAME) ? "" : name + File.separator;
-  }
-
-  @Override
-  public List<Template> getInstalledTemplates() {
-    ArrayList<Template> loadedTemplates = new ArrayList<>();
-    localConfiguration.getRepositoriesWithInstalledTemplates()
-        .forEach(r -> r.getInstalledTemplates().forEach((template, version) -> {
-          String installedTemplateFile =
-              getFileForTemplate(r.getName(), template, version);
-
-          try {
-            Template loadedTemplate = localConfiguration
-                .readValue(new File(installedTemplateFile), Template.class);
-            loadedTemplate.setRepositoryId(r.getName());
-            loadedTemplate.setSnapshot(getSnapshot(loadedTemplate));
-            loadedTemplates.add(loadedTemplate);
-          } catch (IOException e) {
-            LOG.warn("There was an error trying to get the CorrelationTemplate from the file {}",
-                installedTemplateFile, e);
-          }
-        }));
-
-    return loadedTemplates;
-  }
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRepositoriesRegistry.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRepositoriesRegistry.java
index 4bc87ee..68972d0 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRepositoriesRegistry.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRepositoriesRegistry.java
@@ -1,19 +1,13 @@
 package com.blazemeter.jmeter.correlation.core.templates;
 
-import static com.blazemeter.jmeter.correlation.core.templates.LocalCorrelationTemplatesRegistry.PROPERTIES_FILE_SUFFIX;
-import static com.blazemeter.jmeter.correlation.core.templates.LocalCorrelationTemplatesRegistry.SNAPSHOT_FILE_TYPE;
-import static com.blazemeter.jmeter.correlation.core.templates.LocalCorrelationTemplatesRegistry.TEMPLATE_FILE_SUFFIX;
-import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.LOCAL_REPOSITORY_NAME;
 import static com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryUtils.removeRepositoryNameFromFile;
 import static org.apache.commons.io.FileUtils.copyFile;
 
-import com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryUtils;
 import com.blazemeter.jmeter.correlation.core.templates.repository.TemplateProperties;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -28,10 +22,6 @@
 public class LocalCorrelationTemplatesRepositoriesRegistry implements
     CorrelationTemplatesRepositoriesRegistry {
 
-  public static final String SNAPSHOT_SUFFIX = "-snapshot";
-  public static final String SNAPSHOT_FILE_EXTENSION = "." + SNAPSHOT_FILE_TYPE;
-  public static final String SNAPSHOT_FILE_SUFFIX = SNAPSHOT_SUFFIX + SNAPSHOT_FILE_EXTENSION;
-
   private static final Logger LOG = LoggerFactory
       .getLogger(LocalCorrelationTemplatesRepositoriesRegistry.class);
 
@@ -45,38 +35,29 @@ public LocalCorrelationTemplatesRepositoriesRegistry(LocalConfiguration configur
   public void save(String name, String url) throws IOException {
     String path = url.replace("file://", "");
     if (Files.exists(Paths.get(path))) {
-      String repositoryFolderName = name + File.separator;
-
-      String installationFolderPath =
-          Paths.get(
-              configuration.getCorrelationsTemplateInstallationFolder(), repositoryFolderName
-          ).toAbsolutePath() + File.separator;
-
-      File repositoryFolder = new File(installationFolderPath);
+      File repositoryFolder = new File(configuration.getRepositoryFolderPath(name));
       if (!repositoryFolder.exists() && repositoryFolder.mkdir()) {
         LOG.info("Created the folder for the repository {}", name);
         configuration.addRepository(name, url);
       }
-      String repositoryFilePath =
-          installationFolderPath + RepositoryUtils.getRepositoryFileName(name);
-
-      copyFileFromPath(path, repositoryFilePath);
+      copyFileFromPath(path, configuration.getRepositoryFilePath(name));
 
       String basePath = getBasePath(path);
-      Map<String, CorrelationTemplateVersions> templatesReferences = readTemplatesVersions(
-          new File(installationFolderPath + RepositoryUtils.getRepositoryFileName(name)));
+      Map<String, CorrelationTemplateVersions> templatesReferences =
+          configuration.readTemplatesVersions(configuration.getRepositoryFile(name));
 
       for (Map.Entry<String, CorrelationTemplateVersions> entry : templatesReferences.entrySet()) {
         for (String version : entry.getValue().getVersions()) {
-          String templateFileName = entry.getKey() + "-" + version;
+          String templateFilename = configuration.getTemplateFilename(entry.getKey(), version);
+          String snapshotFilename = configuration.getTemplateSnapshotFilename(entry.getKey(),
+              version);
 
-          copyFileFromPath(basePath + templateFileName + TEMPLATE_FILE_SUFFIX,
-              installationFolderPath + templateFileName + TEMPLATE_FILE_SUFFIX);
+          copyFileFromPath(basePath + templateFilename,
+              Paths.get(configuration.getRepositoryFolderPath(name), templateFilename).toString());
 
-          File templateSnapshotFile = new File(basePath + templateFileName + SNAPSHOT_FILE_SUFFIX);
+          File templateSnapshotFile = new File(basePath + snapshotFilename);
           if (templateSnapshotFile.exists()) {
-            copyFileFromPath(basePath + templateFileName + SNAPSHOT_FILE_SUFFIX,
-                templateFileName + SNAPSHOT_FILE_SUFFIX);
+            copyFileFromPath(basePath + snapshotFilename, snapshotFilename);
           }
         }
       }
@@ -97,44 +78,6 @@ private void copyFileFromPath(String source, String templateFileName) throws IOE
     }
   }
 
-  @Override
-  public List<CorrelationTemplatesRepository> getRepositories() {
-    List<CorrelationTemplatesRepository> correlationRepositoryList = new ArrayList<>();
-    List<String> repositoriesList = configuration.getRepositoriesNames();
-    repositoriesList.forEach(r -> {
-      File repositoryFile = new File(
-          Paths.get(
-                  configuration.getCorrelationsTemplateInstallationFolder(),
-                  (
-                      r.equals(LOCAL_REPOSITORY_NAME)
-                          ? ""
-                          : r + File.separator) + RepositoryUtils.getRepositoryFileName(r))
-              .toAbsolutePath().toString()
-      );
-      String repoName = removeRepositoryNameFromFile(repositoryFile.getName());
-      if (repositoryFile.exists()) {
-        try {
-          CorrelationTemplatesRepository loadedRepository =
-              new CorrelationTemplatesRepository(repoName,
-                  readTemplatesVersions(repositoryFile));
-
-          correlationRepositoryList.add(loadedRepository);
-        } catch (IOException e) {
-          LOG.error("There was an issue trying to read the file {}.", repositoryFile.getName(), e);
-        }
-      } else {
-        LOG.warn("Repository file not found {}.", repositoryFile);
-      }
-    });
-
-    return correlationRepositoryList;
-  }
-
-  public Map<String, CorrelationTemplateVersions> readTemplatesVersions(File source)
-      throws IOException {
-    return configuration.readTemplatesReferences(source);
-  }
-
   @Override
   public CorrelationTemplatesRepository find(String id) {
     Optional<String> foundRepository = configuration.getRepositoriesNames().stream()
@@ -145,15 +88,10 @@ public CorrelationTemplatesRepository find(String id) {
       return null;
     }
 
-    String repositoryFolderPath = (id.equals(LOCAL_REPOSITORY_NAME) ? "" : id) + File.separator;
-
     try {
-      File source = new File(
-          Paths.get(
-              configuration.getCorrelationsTemplateInstallationFolder(), repositoryFolderPath,
-              RepositoryUtils.getRepositoryFileName(id)).toAbsolutePath().toString());
-      Map<String, CorrelationTemplateVersions> templatesReferences = readTemplatesVersions(
-          source);
+      File source = configuration.getRepositoryFile(id);
+      Map<String, CorrelationTemplateVersions> templatesReferences =
+          configuration.readTemplatesVersions(source);
 
       return new CorrelationTemplatesRepository(
           removeRepositoryNameFromFile(source.getName()),
@@ -231,8 +169,13 @@ public Map<Template, TemplateProperties> getCorrelationTemplatesAndPropertiesByR
     return relatedTemplates;
   }
 
+  @Override
+  public void upload(String name, Template template) throws IOException {
+    // Do nothing
+  }
+
   private Template loadTemplateFromFile(String repositoryId, File templateFile) throws IOException {
-    Template template = configuration.readValue(templateFile, Template.class);
+    Template template = configuration.readTemplateFromPath(templateFile.getAbsolutePath());
     template.setRepositoryId(repositoryId);
     template.setInstalled(
         configuration.isInstalled(repositoryId, template.getId(), template.getVersion()));
@@ -240,42 +183,30 @@ private Template loadTemplateFromFile(String repositoryId, File templateFile) th
   }
 
   private List<File> getTemplatesFilesByRepositoryId(String id) {
-    return Stream.of(Objects.requireNonNull((new File(
-            configuration.getCorrelationsTemplateInstallationFolder() + (
-                id.equals(LOCAL_REPOSITORY_NAME) ? "" : id)))
-            .listFiles()))
-        .filter(f -> f.getName().endsWith(TEMPLATE_FILE_SUFFIX))
+    File repositoryFolder = configuration.getRepositoryFolder(id);
+    return Stream.of(Objects.requireNonNull((repositoryFolder).listFiles()))
+        .filter(LocalCorrelationTemplatesRepositoriesRegistry::isJsonFile)
         .collect(Collectors.toList());
   }
 
+  private static boolean isJsonFile(File f) {
+    return f.getName().endsWith(RepositoryGeneralConst.TEMPLATE_FILE_SUFFIX);
+  }
+
   private TemplateProperties loadTemplatePropertiesFromFile(File templateFile) throws IOException {
-    String propertiesFilepath =
-        templateFile.getAbsolutePath().replace(TEMPLATE_FILE_SUFFIX, PROPERTIES_FILE_SUFFIX);
-    TemplateProperties templateProperties = new TemplateProperties();
-    if (Files.notExists(Paths.get(propertiesFilepath))) {
-      LOG.warn("The properties file '{}' for the template '{}' was not found.",
-          propertiesFilepath, templateFile.getName());
-    } else {
-      templateProperties =
-          configuration.readValue(new File(propertiesFilepath), TemplateProperties.class);
+    String propertiesFilepath = configuration.getTemplatePropertiesFromFilepath(templateFile);
+    if (Files.exists(Paths.get(propertiesFilepath))) {
+      return configuration.readTemplatePropertiesFromPath(propertiesFilepath);
     }
-    return templateProperties;
+    return new TemplateProperties();
   }
 
   @Override
   public Map<String, CorrelationTemplateVersions> getCorrelationTemplateVersionsByRepositoryId(
       String name) {
-    File repositoryFile = new File(
-        Paths.get(
-                configuration.getCorrelationsTemplateInstallationFolder(),
-                (
-                    name.equals(LOCAL_REPOSITORY_NAME)
-                        ? ""
-                        : name + File.separator) + RepositoryUtils.getRepositoryFileName(name))
-            .toAbsolutePath().toString()
-    );
+    File repositoryFile = configuration.getRepositoryFile(name);
     try {
-      return readTemplatesVersions(repositoryFile);
+      return configuration.readTemplatesVersions(repositoryFile);
     } catch (IOException e) {
       LOG.error("There was an issue trying to read the file {}.", repositoryFile.getName(), e);
     }
@@ -288,69 +219,11 @@ public boolean isLocalTemplateVersionSaved(String templateId, String templateVer
             .listFiles()))
         .anyMatch(f -> f.getName().toLowerCase()
             .startsWith(templateId.toLowerCase() + "-" + templateVersion.toLowerCase())
-            && f.getName().endsWith(TEMPLATE_FILE_SUFFIX));
-  }
-
-  public void installTemplate(String repositoryName, String templateId, String templateVersion)
-      throws ConfigurationException {
-    manageTemplate(LocalConfiguration.INSTALL, repositoryName, templateId, templateVersion);
-  }
-
-  private void manageTemplate(String action, String repositoryName, String templateId,
-                              String templateVersion) throws ConfigurationException {
-
-    String repositoryFolderPath =
-        repositoryName.equals(LOCAL_REPOSITORY_NAME) ? "" : repositoryName + File.separator;
-
-    File template = new File(
-        Paths.get(
-            configuration.getCorrelationsTemplateInstallationFolder(),
-            repositoryFolderPath,
-            templateId + "-" + templateVersion + TEMPLATE_FILE_SUFFIX).toAbsolutePath().toString()
-    );
-
-    if (!template.exists()) {
-      LOG.error("The template {} doesn't exists", template.getName());
-      throw new ConfigurationException(
-          "The template " + template.getAbsolutePath() + " doesn't exists");
-    }
-
-    configuration.manageTemplate(action, repositoryName, templateId, templateVersion);
-  }
-
-  public void uninstallTemplate(String repositoryName, String templateId, String templateVersion)
-      throws ConfigurationException {
-    manageTemplate(LocalConfiguration.UNINSTALL, repositoryName, templateId, templateVersion);
+            && isJsonFile(f));
   }
 
   public String getRepositoryURL(String name) {
     return configuration.getRepositoryURL(name);
   }
-
-  public void updateLocalRepository(String templateId, String templateVersion) {
-    File localRepositoryFile = new File(
-        configuration.getCorrelationsTemplateInstallationFolder()
-            + RepositoryUtils.getRepositoryFileName(LOCAL_REPOSITORY_NAME));
-    try {
-      CorrelationTemplatesRepository localRepository;
-
-      if (!localRepositoryFile.exists()) {
-        localRepositoryFile.createNewFile();
-        localRepository = new CorrelationTemplatesRepository();
-        localRepository.setTemplates(new HashMap<String, CorrelationTemplateVersions>() {
-        });
-        configuration.writeValue(localRepositoryFile, localRepository.getTemplates());
-        LOG.info("No local repository file found. Created a new one instead");
-      } else {
-        localRepository = new CorrelationTemplatesRepository("local",
-            readTemplatesVersions(localRepositoryFile));
-      }
-
-      localRepository.addTemplate(templateId, templateVersion);
-      configuration.writeValue(localRepositoryFile, localRepository.getTemplates());
-      configuration.addRepository(LOCAL_REPOSITORY_NAME, localRepositoryFile.getAbsolutePath());
-    } catch (IOException e) {
-      LOG.warn("There was a problem trying to update the local repository file.", e);
-    }
-  }
+  
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/RemoteCorrelationTemplatesRepositoriesRegistry.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/RemoteCorrelationTemplatesRepositoriesRegistry.java
index 35b854f..fb07990 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/RemoteCorrelationTemplatesRepositoriesRegistry.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/RemoteCorrelationTemplatesRepositoriesRegistry.java
@@ -1,8 +1,5 @@
 package com.blazemeter.jmeter.correlation.core.templates;
 
-import static com.blazemeter.jmeter.correlation.core.templates.LocalCorrelationTemplatesRegistry.PROPERTIES_FILE_SUFFIX;
-import static com.blazemeter.jmeter.correlation.core.templates.LocalCorrelationTemplatesRegistry.TEMPLATE_FILE_SUFFIX;
-
 import com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryUtils;
 import com.blazemeter.jmeter.correlation.core.templates.repository.TemplateProperties;
 import com.fasterxml.jackson.core.JsonParseException;
@@ -48,21 +45,23 @@ public void save(String name, String url) throws IOException {
       String baseURL = getBaseURL(url);
 
       for (Map.Entry<String, CorrelationTemplateVersions> templateReference
-          : readTemplatesVersions(new File(repositoryFilePath)).entrySet()) {
+          : configuration.readTemplatesVersions(new File(repositoryFilePath)).entrySet()) {
         for (String templateVersion : templateReference.getValue().getVersions()) {
-          String templateWithVersionName = templateReference.getKey() + "-" + templateVersion;
-
-          String templateFileName = templateWithVersionName + TEMPLATE_FILE_SUFFIX;
+          String templateName = templateReference.getKey();
+          String templateFileName =
+              configuration.getTemplateFilename(templateName, templateVersion);
           saveFileFromURL(baseURL + encodeSpecialCharacters(templateFileName),
               Paths.get(installationFolderPath, templateFileName).toAbsolutePath().toString());
 
-          String snapshotFileName = templateWithVersionName + SNAPSHOT_FILE_SUFFIX;
+          String snapshotFileName = configuration
+              .getTemplateSnapshotFilename(templateName, templateVersion);
           if (canDownload(baseURL + snapshotFileName)) {
             saveFileFromURL(baseURL + encodeSpecialCharacters(snapshotFileName),
                 Paths.get(installationFolderPath, snapshotFileName).toAbsolutePath().toString());
           }
 
-          String propertiesFileName = templateWithVersionName + PROPERTIES_FILE_SUFFIX;
+          String propertiesFileName = configuration
+              .getTemplatePropertiesFilename(templateName, templateVersion);
           File propertiesFile = Paths.get(installationFolderPath, propertiesFileName).toFile();
           configuration.writeValue(propertiesFile, new TemplateProperties());
         }
@@ -75,6 +74,18 @@ public void save(String name, String url) throws IOException {
     }
   }
 
+  /**
+   * Uploads a template into the repository.
+   *
+   * @param name     name of the repository
+   * @param template template to upload
+   * @throws IOException if there is an error uploading the template
+   */
+  @Override
+  public void upload(String name, Template template) throws IOException {
+    // Left empty for custom implementations to override
+  }
+
   private void saveFileFromURL(String fileURL, String fileFullPath) throws IOException {
     File templateFile = new File(fileFullPath);
     if (templateFile.exists() || templateFile.createNewFile()) {
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/RepositoryGeneralConst.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/RepositoryGeneralConst.java
index ed06228..23aa909 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/RepositoryGeneralConst.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/RepositoryGeneralConst.java
@@ -3,11 +3,13 @@
 public class RepositoryGeneralConst {
   public static final String LOCAL_REPOSITORY_NAME = "local";
   public static final String CENTRAL_REPOSITORY_NAME = "central";
-  public static final String JSON_FILE_EXTENSION = ".json";
+  public static final String BZM_CENTRAL_REPOSITORY_NAME = "bzm-central";
   public static final String REPOSITORY_NAME_SUFFIX = "-repository";
-
+  public static final String JSON_FILE_EXTENSION = ".json";
+  public static final String TEMPLATE_FILE_SUFFIX = "-template" + JSON_FILE_EXTENSION;
+  public static final String SNAPSHOT_FILE_TYPE = "png";
+  public static final String SNAPSHOT_FILE_SUFFIX = "-snapshot." + SNAPSHOT_FILE_TYPE;
+  public static final String PROPERTIES_FILE_SUFFIX = "-properties" + JSON_FILE_EXTENSION;
   public static final String TEMPLATE_PROPERTY_NOT_ALLOW_EXPORT = "not_allow_export";
-
   public static final String TEMPLATE_PROPERTY_DISALLOW_TO_USE = "disallow_to_use";
-
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/Template.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/Template.java
index b26bd39..b167ab9 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/Template.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/Template.java
@@ -91,6 +91,10 @@ public String getVersion() {
     return version;
   }
 
+  public void setVersion(String version) {
+    this.version = version;
+  }
+
   public BufferedImage getSnapshot() {
     return snapshot;
   }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/RepositoryRegistry.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/RepositoryRegistry.java
index 79b3aea..1d6fa59 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/RepositoryRegistry.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/RepositoryRegistry.java
@@ -5,6 +5,7 @@
 import com.blazemeter.jmeter.correlation.core.templates.LocalConfiguration;
 import com.blazemeter.jmeter.correlation.core.templates.Template;
 import com.blazemeter.jmeter.correlation.core.templates.TemplateVersion;
+import java.io.IOException;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -17,6 +18,8 @@ public interface RepositoryRegistry {
 
   String getName();
 
+  void setEndPoint(String endPoint);
+
   String getEndPoint();
 
   void setup();
@@ -46,4 +49,11 @@ public interface RepositoryRegistry {
   Map<Template, TemplateProperties> getTemplatesAndProperties();
 
   Map<Template, TemplateProperties> getTemplatesAndProperties(List<TemplateVersion> filter);
+
+  void upload(Template template) throws IOException;
+
+  void setDisplayName(String displayName);
+
+  String getDisplayName();
+
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/CentralRepository.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/CentralRepository.java
index 91bf6ef..df061f5 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/CentralRepository.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/CentralRepository.java
@@ -10,6 +10,7 @@
 import com.blazemeter.jmeter.correlation.core.templates.repository.PluggableRepository;
 import com.blazemeter.jmeter.correlation.core.templates.repository.RemoteRepository;
 import com.blazemeter.jmeter.correlation.core.templates.repository.TemplateProperties;
+import java.io.IOException;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -24,6 +25,11 @@ public String getName() {
     return CENTRAL_REPOSITORY_NAME;
   }
 
+  @Override
+  public void setEndPoint(String endPoint) {
+    // Not allowed
+  }
+
   @Override
   public String getEndPoint() {
     return CENTRAL_REPOSITORY_URL;
@@ -64,6 +70,21 @@ public Map<Template, TemplateProperties> getTemplatesAndProperties(List<Template
     return new HashMap<>();
   }
 
+  @Override
+  public void upload(Template template) throws IOException {
+    // Left empty intentionally for development purposes
+  }
+
+  @Override
+  public void setDisplayName(String displayName) {
+    // Left empty intentionally for development purposes
+  }
+
+  @Override
+  public String getDisplayName() {
+    return CENTRAL_REPOSITORY_NAME;
+  }
+
   private static Map<String, String> getDefaultProperties() {
     Map<String, String> props = new HashMap<>();
     props.put(RepositoryGeneralConst.TEMPLATE_PROPERTY_DISALLOW_TO_USE, "false");
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/LocalRepository.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/LocalRepository.java
index e1a9d0a..bea9953 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/LocalRepository.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/LocalRepository.java
@@ -2,6 +2,7 @@
 
 import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.LOCAL_REPOSITORY_NAME;
 
+import com.blazemeter.jmeter.correlation.core.templates.ConfigurationException;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplateVersions;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepository;
 import com.blazemeter.jmeter.correlation.core.templates.LocalConfiguration;
@@ -29,6 +30,11 @@ public String getName() {
     return LOCAL_REPOSITORY_NAME;
   }
 
+  @Override
+  public void setEndPoint(String endPoint) {
+    // Not allowed
+  }
+
   @Override
   public void setup() {
     File localRepositoryFile = getRepositoryFile();
@@ -39,8 +45,10 @@ public void setup() {
         this.getConfig()
             .writeValue(localRepositoryFile, new HashMap<String, CorrelationTemplateVersions>() {
               {
-                put(SIEBEL_TEMPLATE_NAME,
-                    new CorrelationTemplateVersions(DEFAULT_SIEBEL_TEMPLATE_VERSION));
+                CorrelationTemplateVersions value =
+                    new CorrelationTemplateVersions(DEFAULT_SIEBEL_TEMPLATE_VERSION);
+                value.setRepositoryDisplayName(LOCAL_REPOSITORY_NAME);
+                put(SIEBEL_TEMPLATE_NAME, value);
               }
             });
         LOG.info("Saved local repository file");
@@ -79,13 +87,6 @@ public List<Template> getTemplates(List<TemplateVersion> filter) {
     return null;
   }
 
-  private static Map<String, String> getDefaultProperties() {
-    Map<String, String> props = new HashMap<>();
-    props.put(RepositoryGeneralConst.TEMPLATE_PROPERTY_DISALLOW_TO_USE, "false");
-    props.put(RepositoryGeneralConst.TEMPLATE_PROPERTY_NOT_ALLOW_EXPORT, "false");
-    return props;
-  }
-
   @Override
   public Map<Template, TemplateProperties> getTemplatesAndProperties() {
     return null;
@@ -96,16 +97,34 @@ public Map<Template, TemplateProperties> getTemplatesAndProperties(List<Template
     return null;
   }
 
+  @Override
+  public void upload(Template template) throws IOException {
+    // Left empty intentionally for development purposes
+  }
+
+  @Override
+  public String getDisplayName() {
+    return LOCAL_REPOSITORY_NAME;
+  }
+
+  @Override
+  public void setDisplayName(String displayName) {
+    // Left empty intentionally for development purposes
+  }
+
   private boolean isSiebelInstalled() {
     return this.getConfig().isInstalled(getName(), SIEBEL_TEMPLATE_NAME);
   }
 
   private void installSiebel() {
-    this.getConfig().getRepositories().stream()
-        .filter(r -> r.getName().equals(getName()))
-        .findFirst().get()
-        .installTemplate(
-            LocalRepository.SIEBEL_TEMPLATE_NAME, LocalRepository.DEFAULT_SIEBEL_TEMPLATE_VERSION);
+    if (!isSiebelInstalled()) {
+      try {
+        this.getConfig().installTemplate(RepositoryGeneralConst.LOCAL_REPOSITORY_NAME,
+            SIEBEL_TEMPLATE_NAME, DEFAULT_SIEBEL_TEMPLATE_VERSION);
+      } catch (ConfigurationException e) {
+        LOG.error("Error installing Siebel template", e);
+      }
+    }
     this.getConfig().saveLocalConfiguration();
   }
 
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/RemoteFolderRepository.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/RemoteFolderRepository.java
index 2dae100..f5605ea 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/RemoteFolderRepository.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/RemoteFolderRepository.java
@@ -25,11 +25,6 @@ public class RemoteFolderRepository extends FileRepository {
   private String name;
   private String url;
 
-  public RemoteFolderRepository(String name, String url) {
-    this.name = name;
-    this.url = url;
-  }
-
   @Override
   public void init() {
     super.init();
@@ -108,11 +103,36 @@ public Map<Template, TemplateProperties> getTemplatesAndProperties(List<Template
     return null;
   }
 
+  @Override
+  public void upload(Template template) throws IOException {
+    throw new UnsupportedOperationException("Upload is not supported for remote repositories");
+  }
+
+  @Override
+  public void setDisplayName(String displayName) {
+    // Left empty intentionally for development purposes
+  }
+
+  @Override
+  public String getDisplayName() {
+    return null;
+  }
+
+  @Override
+  public void setName(String name) {
+    this.name = name;
+  }
+
   @Override
   public String getName() {
     return name;
   }
 
+  @Override
+  public void setEndPoint(String endPoint) {
+    this.url = endPoint;
+  }
+
   @Override
   public String getEndPoint() {
     return url;
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/RemoteUrlRepository.java b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/RemoteUrlRepository.java
index 403cf48..3066b85 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/RemoteUrlRepository.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/core/templates/repository/pluggable/RemoteUrlRepository.java
@@ -25,11 +25,6 @@ public class RemoteUrlRepository extends RemoteRepository {
   private String name;
   private String url;
 
-  public RemoteUrlRepository(String name, String url) {
-    this.name = name;
-    this.url = url;
-  }
-
   @Override
   public void init() {
     super.init();
@@ -121,6 +116,21 @@ public Map<Template, TemplateProperties> getTemplatesAndProperties(List<Template
     return null;
   }
 
+  @Override
+  public void upload(Template template) throws IOException {
+    // Left empty intentionally for development purposes
+  }
+
+  @Override
+  public void setDisplayName(String displayName) {
+    // Left empty intentionally for development purposes
+  }
+
+  @Override
+  public String getDisplayName() {
+    return null;
+  }
+
   @Override
   public void setName(String name) {
     this.name = name;
@@ -131,6 +141,11 @@ public String getName() {
     return name;
   }
 
+  @Override
+  public void setEndPoint(String endPoint) {
+    this.url = endPoint;
+  }
+
   @Override
   public String getEndPoint() {
     return url;
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/RulesContainer.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/RulesContainer.java
index 4c511d9..18509cb 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/gui/RulesContainer.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/RulesContainer.java
@@ -20,10 +20,8 @@
 import java.awt.event.ActionListener;
 import java.awt.image.BufferedImage;
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -55,7 +53,7 @@ public class RulesContainer extends JPanel implements ActionListener {
   private final CorrelationTemplatesRegistryHandler templatesRegistryHandler;
   private final CorrelationTemplatesRepositoriesRegistryHandler repositoriesRegistryHandler;
   private final Runnable modelUpdater;
-  private final Set<Template> loadedTemplates;
+  private final List<Template> loadedTemplates;
   private final GroupsContainer groupsContainer;
   private final ResponseFilterPanel responseFilterPanel;
   private TemplateSaveFrame templateFrame;
@@ -73,7 +71,7 @@ public RulesContainer(CorrelationTemplatesRegistryHandler correlationTemplatesRe
     templatesRegistryHandler = correlationTemplatesRegistryHandler;
     repositoriesRegistryHandler =
         (CorrelationTemplatesRepositoriesRegistryHandler) correlationTemplatesRegistryHandler;
-    loadedTemplates = new HashSet<>();
+    loadedTemplates = new ArrayList<>();
     setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
     add(makeTemplateButtonPanel());
     groupsContainer = new GroupsContainer(modelUpdater);
@@ -156,6 +154,7 @@ public void actionPerformed(ActionEvent e) {
       case SAVE:
         if (templateFrame == null) {
           templateFrame = new TemplateSaveFrame(templatesRegistryHandler,
+              repositoriesRegistryHandler,
               getSnapshotBufferedImage(), this::updateLoadedTemplate, this);
         }
         displaySaveTemplateFrame();
@@ -192,17 +191,15 @@ private void clearContainer() {
      * If we don't force the update the of the Model
      * with the info in the RulesContainer,
      * the rules "stored" in the Model won't reset
-     * and will be appended on LoadTemplate
+     * and will be appended on LoadTemplateLoadTemplate
      * */
     modelUpdater.run();
   }
 
   private void displaySaveTemplateFrame() {
-    templateFrame.clear();
     if (!loadedTemplates.isEmpty()) {
-      templateFrame.setLoadedTemplates(loadedTemplates);
+      templateFrame.setLoadedTemplates(loadedTemplates.get(loadedTemplates.size() - 1));
     }
-    templateFrame.setTemplateSnapshot(getSnapshotBufferedImage());
     templateFrame.showFrame();
   }
 
@@ -280,10 +277,7 @@ private void setResponseFilter(String responseFilter) {
   }
 
   public void updateLoadedTemplate(Template template) {
-    if (loadedTemplates.add(template)) {
-      LOG.debug("Updated loaded templates. New Total={}. 'Last Template' = {}. ",
-          loadedTemplates.size(), template);
-    }
+    loadedTemplates.add(template);
   }
 
   @Override
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/TestPlanTemplatesRepository.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/TestPlanTemplatesRepository.java
index da5df99..0e5feb1 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/gui/TestPlanTemplatesRepository.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/TestPlanTemplatesRepository.java
@@ -26,12 +26,22 @@ public class TestPlanTemplatesRepository {
   private String rootFolder;
 
   public TestPlanTemplatesRepository(String rootFolder) {
+    try {
+      Files.createDirectories(Paths.get(rootFolder));
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
     this.rootFolder = rootFolder;
   }
 
   @VisibleForTesting
   public void setRootFolder(String rootFolder) {
     this.rootFolder = rootFolder;
+    try {
+      Files.createDirectories(Paths.get(rootFolder));
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
   }
 
   public void addCorrelationRecorderTemplate(String templateFileName, String templatesFolderPath,
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/analysis/CorrelationTemplatesSelectionPanel.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/analysis/CorrelationTemplatesSelectionPanel.java
index 9580bb8..a9a1021 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/gui/analysis/CorrelationTemplatesSelectionPanel.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/analysis/CorrelationTemplatesSelectionPanel.java
@@ -294,9 +294,8 @@ private void reloadCorrelationTemplates() {
     UpdateRepositoriesWorker worker = new UpdateRepositoriesWorker() {
       @Override
       protected Boolean doInBackground() {
-        return wizard.getRepositoriesConfiguration().refreshRepositories(
-            wizard.getRepositoriesConfiguration().getLocalRootFolder(), this::setProgress,
-            this::publish);
+        return wizard.getConfiguration().refreshRepositories("",
+            this::setProgress, this::publish);
       }
     };
 
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/automatic/CorrelationWizard.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/automatic/CorrelationWizard.java
index 334149b..e4adc6e 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/gui/automatic/CorrelationWizard.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/automatic/CorrelationWizard.java
@@ -10,6 +10,7 @@
 import com.blazemeter.jmeter.correlation.core.automatic.ReplayReport;
 import com.blazemeter.jmeter.correlation.core.automatic.ReplayWorker;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepositoriesConfiguration;
+import com.blazemeter.jmeter.correlation.core.templates.LocalConfiguration;
 import com.blazemeter.jmeter.correlation.core.templates.Repository;
 import com.blazemeter.jmeter.correlation.core.templates.Template;
 import com.blazemeter.jmeter.correlation.gui.analysis.CorrelationTemplatesSelectionPanel;
@@ -57,6 +58,8 @@ public class CorrelationWizard extends JDialog {
 
   private CorrelationTemplatesRepositoriesConfiguration repositoriesConfiguration;
 
+  private LocalConfiguration configuration;
+
   public CorrelationWizard() {
     super();
     setTitle(TITLE);
@@ -459,4 +462,13 @@ public CorrelationTemplatesRepositoriesConfiguration getRepositoriesConfiguratio
   public Supplier<Map<String, Repository>> getRepositoriesSupplier() {
     return repositoriesSupplier;
   }
+
+  public LocalConfiguration getConfiguration() {
+    return configuration;
+  }
+
+  public void setConfiguration(
+      LocalConfiguration configuration) {
+    this.configuration = configuration;
+  }
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/PlaceHolderComboBox.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/PlaceHolderComboBox.java
new file mode 100644
index 0000000..88df9a6
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/PlaceHolderComboBox.java
@@ -0,0 +1,139 @@
+package com.blazemeter.jmeter.correlation.gui.templates;
+
+import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplateVersions;
+import com.blazemeter.jmeter.correlation.gui.common.PlaceHolderTextField;
+import java.awt.Component;
+import java.awt.event.ActionListener;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import java.util.List;
+import javax.swing.ComboBoxEditor;
+import javax.swing.DefaultComboBoxModel;
+import javax.swing.DefaultListCellRenderer;
+import javax.swing.JComboBox;
+import javax.swing.JList;
+
+public class PlaceHolderComboBox extends JComboBox<CorrelationTemplateVersions> {
+
+  public PlaceHolderComboBox() {
+    super();
+    setEditable(true);
+
+    PlaceHolderTextField placeholderTextField = new PlaceHolderTextField();
+    placeholderTextField.setPlaceHolder("Type a new template name or select existing");
+    placeholderTextField.setBorder(null);
+    placeholderTextField.setName("templateName");
+    setEditor(new PlaceholderComboBoxEditor(placeholderTextField));
+    setSelectedItem(null);
+    setRenderer(new DefaultListCellRenderer() {
+      @Override
+      public Component getListCellRendererComponent(JList<?> list, Object value,
+                                                    int index, boolean isSelected,
+                                                    boolean cellHasFocus) {
+        Component component =
+            super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+        if (value instanceof CorrelationTemplateVersions) {
+          setText(((CorrelationTemplateVersions) value).getName());
+        }
+        return component;
+      }
+    });
+  }
+
+  public void setTemplates(List<CorrelationTemplateVersions> templates) {
+    DefaultComboBoxModel<CorrelationTemplateVersions> model =
+        new DefaultComboBoxModel<>(templates.toArray(new CorrelationTemplateVersions[0]));
+    setModel(model);
+    setSelectedItem(null);
+  }
+
+  private class PlaceholderComboBoxEditor implements ComboBoxEditor {
+    private PlaceHolderTextField textField;
+
+    PlaceholderComboBoxEditor(PlaceHolderTextField textField) {
+      this.textField = textField;
+    }
+
+    @Override
+    public Component getEditorComponent() {
+      return textField;
+    }
+
+    @Override
+    public void setItem(Object anObject) {
+      if (anObject instanceof CorrelationTemplateVersions) {
+        textField.setText(((CorrelationTemplateVersions) anObject).getName());
+      } else {
+        textField.setText("");
+      }
+    }
+
+    @Override
+    public Object getItem() {
+      String text = textField.getText();
+      for (int i = 0; i < getItemCount(); i++) {
+        CorrelationTemplateVersions template = getItemAt(i);
+        if (template.getName().equals(text)) {
+          return template;
+        }
+      }
+      return null;
+    }
+
+    @Override
+    public void selectAll() {
+      textField.selectAll();
+    }
+
+    @Override
+    public void addActionListener(ActionListener l) {
+      textField.addActionListener(l);
+    }
+
+    @Override
+    public void removeActionListener(ActionListener l) {
+      textField.removeActionListener(l);
+    }
+
+  }
+
+  public void resetToDefault() {
+    removeAllItems();
+    setSelectedItem(null);
+  }
+
+  public List<String> getSelectedTemplateVersions() {
+    return getSelectedTemplate().getVersions();
+  }
+
+  public CorrelationTemplateVersions getSelectedTemplate() {
+    Object item = getEditor().getItem();
+
+    PlaceHolderTextField editorComponent = (PlaceHolderTextField) getEditor().getEditorComponent();
+    String text = editorComponent.getText();
+    if (text.isEmpty()) {
+      CorrelationTemplateVersions templateVersions = new CorrelationTemplateVersions();
+      templateVersions.setName("");
+      templateVersions.addVersion("0.0.0");
+      return templateVersions;
+    } else {
+      if (item instanceof CorrelationTemplateVersions) {
+        return (CorrelationTemplateVersions) item;
+      } else {
+        CorrelationTemplateVersions templateVersions = new CorrelationTemplateVersions();
+        templateVersions.setName(text);
+        templateVersions.addVersion("0.0.0");
+        return templateVersions;
+      }
+    }
+  }
+
+  public void addEditorLostFocusListener(ActionListener l) {
+    getEditor().getEditorComponent().addFocusListener(new FocusAdapter() {
+      @Override
+      public void focusLost(FocusEvent e) {
+        l.actionPerformed(null);
+      }
+    });
+  }
+}
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateDependenciesTable.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateDependenciesTable.java
new file mode 100644
index 0000000..faed53e
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateDependenciesTable.java
@@ -0,0 +1,307 @@
+package com.blazemeter.jmeter.correlation.gui.templates;
+
+import com.blazemeter.jmeter.commons.SwingUtils;
+import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplateDependency;
+import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRegistryHandler;
+import com.helger.commons.annotation.VisibleForTesting;
+import java.awt.Dimension;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.swing.BorderFactory;
+import javax.swing.GroupLayout;
+import javax.swing.JButton;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.ListSelectionModel;
+import org.apache.jmeter.gui.util.HeaderAsPropertyRenderer;
+import org.apache.jmeter.util.JMeterUtils;
+import org.apache.jorphan.gui.GuiUtils;
+import org.apache.jorphan.gui.ObjectTableModel;
+import org.apache.jorphan.reflect.Functor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TemplateDependenciesTable extends JTable implements ActionListener {
+  private static final Logger LOG = LoggerFactory.getLogger(TemplateSaveFrame.class);
+  private static final String ADD = "add";
+  private static final String DELETE = "delete";
+  private static final String CLEAR = "clear";
+  private ObjectTableModel dependencyModel;
+
+  private CorrelationTemplatesRegistryHandler templatesRegistry;
+
+  private boolean hasRepeatedDependencies = false;
+  private boolean hasFailingURLs = false;
+  private List<CorrelationTemplateDependency> dependenciesList = new ArrayList<>();
+
+  public TemplateDependenciesTable() {
+    super();
+  }
+
+  @Override
+  public void actionPerformed(ActionEvent e) {
+    String action = e.getActionCommand();
+    switch (action) {
+      case ADD:
+        addRow();
+        break;
+      case DELETE:
+        deleteRow();
+        break;
+      case CLEAR:
+        clearTable();
+        break;
+      default:
+        LOG.warn("Unsupported action {}", action);
+        JMeterUtils
+            .reportErrorToUser("Unsupported action " + action, "Managing Repositories & Templates");
+    }
+  }
+
+  private void addRow() {
+    GuiUtils.stopTableEditing(this);
+    dependencyModel.addRow(new CorrelationTemplateDependency());
+    int rowToSelect = this.getRowCount() - 1;
+    this.setRowSelectionInterval(rowToSelect, rowToSelect);
+    this.scrollRectToVisible(this.getCellRect(rowToSelect, 0, true));
+  }
+
+  private void deleteRow() {
+    GuiUtils.cancelEditing(this);
+
+    int[] rowsSelected = this.getSelectedRows();
+    int anchorSelection = this.getSelectionModel().getAnchorSelectionIndex();
+    this.clearSelection();
+    if (rowsSelected.length > 0) {
+      for (int i = rowsSelected.length - 1; i >= 0; i--) {
+        dependencyModel.removeRow(rowsSelected[i]);
+      }
+
+      if (dependencyModel.getRowCount() > 0) {
+        if (anchorSelection >= dependencyModel.getRowCount()) {
+          anchorSelection = dependencyModel.getRowCount() - 1;
+        }
+        this.setRowSelectionInterval(anchorSelection, anchorSelection);
+      }
+    }
+  }
+
+  private void clearTable() {
+    dependencyModel.clearData();
+  }
+
+  @VisibleForTesting
+  public List<CorrelationTemplateDependency> getDependencies() {
+    return (List<CorrelationTemplateDependency>) dependencyModel.getObjectList();
+  }
+
+  public Iterator<CorrelationTemplateDependency> getDependenciesIterator() {
+    return (Iterator<CorrelationTemplateDependency>) dependencyModel.iterator();
+  }
+
+  public void clear() {
+    dependencyModel.clearData();
+  }
+
+  public JPanel prepareDependenciesPanel() {
+    JPanel templateDependenciesButtonsPanel = buildDependencyButtonPanel();
+    JLabel dependencyOverwriteLabel = new JLabel("Repeated dependencies will be overwritten.");
+    dependencyOverwriteLabel.setPreferredSize(new Dimension(300, 30));
+    JScrollPane templateDependenciesScroll = prepareDependenciesTable();
+    templateDependenciesScroll.setPreferredSize(new Dimension(300, 200));
+
+    JPanel dependenciesPanel = new JPanel();
+    GroupLayout dependenciesLayout = new GroupLayout(dependenciesPanel);
+    dependenciesPanel.setLayout(dependenciesLayout);
+
+    dependenciesLayout.setHorizontalGroup(dependenciesLayout.createParallelGroup()
+        .addComponent(templateDependenciesScroll)
+        .addComponent(dependencyOverwriteLabel, GroupLayout.Alignment.CENTER)
+        .addComponent(templateDependenciesButtonsPanel)
+    );
+
+    dependenciesLayout.setVerticalGroup(dependenciesLayout.createSequentialGroup()
+        .addComponent(templateDependenciesScroll)
+        .addComponent(dependencyOverwriteLabel)
+        .addComponent(templateDependenciesButtonsPanel)
+    );
+
+    return dependenciesPanel;
+  }
+
+  private JPanel buildDependencyButtonPanel() {
+    SwingUtils.ButtonBuilder base = new SwingUtils.ButtonBuilder()
+        .withActionListener(this);
+
+    JButton deleteButton = base.withName("delete").withAction(DELETE).build();
+    JButton clearButton = base.withName("clear").withAction(CLEAR).build();
+
+    JPanel buttonPanel = new JPanel();
+    buttonPanel.setPreferredSize(new Dimension(300, 50));
+    buttonPanel.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10));
+    buttonPanel.add(base.withName("add").withAction(ADD).build());
+    buttonPanel.add(deleteButton);
+    buttonPanel.add(clearButton);
+    return buttonPanel;
+  }
+
+  private JScrollPane prepareDependenciesTable() {
+    dependencyModel = new ObjectTableModel(new String[] {"Name", "Version", "URL"},
+        CorrelationTemplateDependency.class,
+        new Functor[] {new Functor("getName"), new Functor("getVersion"), new Functor("getUrl")},
+        new Functor[] {new Functor("setName"), new Functor("setVersion"), new Functor("setUrl")},
+        new Class[] {String.class, String.class, String.class});
+
+    setModel(dependencyModel);
+
+    this.setPreferredSize(new Dimension(300, 200));
+    this.setName("templateDependenciesScroll");
+    this.getColumnModel().getColumn(0).setPreferredWidth(50);
+    this.getColumnModel().getColumn(1).setPreferredWidth(50);
+    this.getColumnModel().getColumn(2).setPreferredWidth(200);
+    this.getTableHeader().setDefaultRenderer(new HeaderAsPropertyRenderer());
+    this.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+    this.getTableHeader().setDefaultRenderer(new HeaderAsPropertyRenderer() {
+      @Override
+      protected String getText(Object value, int row, int column) {
+        return (value == null) ? "" : value.toString();
+      }
+    });
+    JMeterUtils.applyHiDPI(this);
+    JScrollPane pane = new JScrollPane(this);
+    pane.setName("templateDependenciesScroll");
+    pane.setPreferredSize(new Dimension(350, 150));
+    return pane;
+  }
+
+  public JPanel getJPanel() {
+    SwingUtils.ButtonBuilder base = new SwingUtils.ButtonBuilder()
+        .withActionListener(this);
+
+    JButton deleteButton = base.withName("delete").withAction(DELETE).build();
+    JButton clearButton = base.withName("clear").withAction(CLEAR).build();
+
+    JPanel buttonPanel = new JPanel();
+    buttonPanel.setPreferredSize(new Dimension(300, 50));
+    buttonPanel.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10));
+    buttonPanel.add(base.withName("add").withAction(ADD).build());
+    buttonPanel.add(deleteButton);
+    buttonPanel.add(clearButton);
+    return buttonPanel;
+  }
+
+  public boolean hasDependencies() {
+    return dependencyModel.getRowCount() > 0;
+  }
+
+  public void setDependencies(List<CorrelationTemplateDependency> dependencies) {
+    dependencyModel.clearData();
+    dependencies.forEach(dependencyModel::addRow);
+  }
+
+  public void validateDependencies() {
+    hasRepeatedDependencies = false;
+    hasFailingURLs = false;
+    processDependenciesInformation();
+  }
+
+  public void processDependenciesInformation() {
+    boolean hasFailingURLs = false;
+    boolean hasRepeatedDependencies = false;
+    List<CorrelationTemplateDependency> rawDependencies = getDependencies();
+    if (hasDependencies()) {
+      Iterator<CorrelationTemplateDependency> iterator = getDependenciesIterator();
+
+      boolean allDependenciesComplete = true;
+      int dependencyIndex = 0;
+      while (iterator.hasNext()) {
+        dependencyIndex++;
+        CorrelationTemplateDependency dependency = iterator.next();
+        if (hasRowEmptyValues(dependency, dependencyIndex)) {
+          allDependenciesComplete = false;
+          continue;
+        }
+
+        List<CorrelationTemplateDependency> repeatedDependencies = rawDependencies.stream()
+            .filter(d -> d.getName().trim().toLowerCase()
+                .equals(dependency.getName().trim().toLowerCase()))
+            .collect(Collectors.toList());
+
+        if (!repeatedDependencies.isEmpty()) {
+          hasRepeatedDependencies = true;
+          rawDependencies.removeAll(repeatedDependencies);
+        }
+
+        if (!templatesRegistry.isValidDependencyURL(dependency.getUrl(), dependency.getName(),
+            dependency.getVersion())) {
+          hasFailingURLs = true;
+          continue;
+        }
+
+        rawDependencies.add(dependency);
+      }
+    }
+    dependenciesList = rawDependencies;
+  }
+
+  private boolean hasRowEmptyValues(CorrelationTemplateDependency dependency, int dependencyIndex) {
+    boolean allFieldComplete = true;
+    if (isBlank(dependency.getName())) {
+      LOG.error("The dependency in the row {}, has no name.", dependencyIndex);
+      allFieldComplete = false;
+    }
+    if (isBlank(dependency.getUrl())) {
+      LOG.error("The dependency in the row {}, has no url.", dependencyIndex);
+      allFieldComplete = false;
+    }
+    if (isBlank(dependency.getVersion())) {
+      LOG.error("The dependency in the row {}, has no version.", dependencyIndex);
+      allFieldComplete = false;
+    }
+    return !allFieldComplete;
+  }
+
+  public static boolean isBlank(String str) {
+    return str == null || str.trim().isEmpty();
+  }
+
+  public boolean isHasRepeatedDependencies() {
+    return hasRepeatedDependencies;
+  }
+
+  public void setHasRepeatedDependencies(boolean hasRepeatedDependencies) {
+    this.hasRepeatedDependencies = hasRepeatedDependencies;
+  }
+
+  public boolean isHasFailingURLs() {
+    return hasFailingURLs;
+  }
+
+  public void setHasFailingURLs(boolean hasFailingURLs) {
+    this.hasFailingURLs = hasFailingURLs;
+  }
+
+  public List<CorrelationTemplateDependency> getDependenciesList() {
+    return dependenciesList;
+  }
+
+  public void setDependenciesList(
+      List<CorrelationTemplateDependency> dependenciesList) {
+    this.dependenciesList = dependenciesList;
+  }
+
+  public CorrelationTemplatesRegistryHandler getTemplatesRegistry() {
+    return templatesRegistry;
+  }
+
+  public void setTemplatesRegistry(
+      CorrelationTemplatesRegistryHandler templatesRegistry) {
+    this.templatesRegistry = templatesRegistry;
+  }
+}
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateManagerDisplay.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateManagerDisplay.java
index b5853c8..365db7b 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateManagerDisplay.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateManagerDisplay.java
@@ -10,6 +10,8 @@ public class TemplateManagerDisplay {
   private String id;
   private boolean hasInstalled;
 
+  private String repositoryName = "N/A";
+
   public TemplateManagerDisplay(String id, boolean hasInstalled) {
     this.id = id;
     this.hasInstalled = hasInstalled;
@@ -39,4 +41,12 @@ public void setHasInstalled(boolean hasInstalled) {
   public List<Template> getVersions() {
     return versions;
   }
+
+  public String getRepositoryName() {
+    return repositoryName;
+  }
+
+  public void setRepositoryName(String repositoryName) {
+    this.repositoryName = repositoryName;
+  }
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateSaveFrame.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateSaveFrame.java
index 5c1e138..5971408 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateSaveFrame.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateSaveFrame.java
@@ -3,325 +3,595 @@
 import static com.blazemeter.jmeter.correlation.core.templates.RepositoryGeneralConst.LOCAL_REPOSITORY_NAME;
 
 import com.blazemeter.jmeter.commons.SwingUtils;
+import com.blazemeter.jmeter.correlation.core.DescriptionContent;
 import com.blazemeter.jmeter.correlation.core.templates.ConfigurationException;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplateDependency;
+import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplateVersions;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRegistryHandler;
+import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepositoriesRegistryHandler;
+import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepository;
 import com.blazemeter.jmeter.correlation.core.templates.Template;
 import com.blazemeter.jmeter.correlation.core.templates.Template.Builder;
 import com.blazemeter.jmeter.correlation.gui.common.CollapsiblePanel;
+import com.blazemeter.jmeter.correlation.gui.common.HelperDialog;
 import com.blazemeter.jmeter.correlation.gui.common.PlaceHolderTextField;
+import com.blazemeter.jmeter.correlation.gui.common.ThemedIconLabel;
+import com.blazemeter.jmeter.correlation.gui.templates.validations.Condition;
+import com.blazemeter.jmeter.correlation.gui.templates.validations.ValidationManager;
+import com.blazemeter.jmeter.correlation.gui.templates.validations.type.NotEmptyCondition;
+import com.blazemeter.jmeter.correlation.gui.templates.validations.type.UniqueVersionCondition;
 import com.helger.commons.annotation.VisibleForTesting;
 import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Cursor;
 import java.awt.Dimension;
-import java.awt.Font;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
-import java.awt.event.FocusAdapter;
-import java.awt.event.FocusEvent;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Iterator;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
-import java.util.Optional;
-import java.util.Set;
+import java.util.Map;
 import java.util.function.Consumer;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import javax.swing.BorderFactory;
+import javax.swing.DefaultListCellRenderer;
 import javax.swing.GroupLayout;
 import javax.swing.GroupLayout.Alignment;
 import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
 import javax.swing.JDialog;
 import javax.swing.JFrame;
 import javax.swing.JLabel;
+import javax.swing.JList;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
-import javax.swing.JTable;
+import javax.swing.JTabbedPane;
 import javax.swing.JTextArea;
 import javax.swing.JTextField;
-import javax.swing.ListSelectionModel;
+import javax.swing.KeyStroke;
 import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
 import javax.swing.border.Border;
 import javax.swing.text.JTextComponent;
-import org.apache.jmeter.gui.util.HeaderAsPropertyRenderer;
-import org.apache.jmeter.util.JMeterUtils;
-import org.apache.jorphan.gui.GuiUtils;
-import org.apache.jorphan.gui.ObjectTableModel;
-import org.apache.jorphan.reflect.Functor;
+import org.apache.jorphan.gui.ComponentUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class TemplateSaveFrame extends JDialog implements ActionListener {
 
   private static final Logger LOG = LoggerFactory.getLogger(TemplateSaveFrame.class);
-
   private static final int FIELD_WIDTH = 350;
   private static final int LABEL_WIDTH = 70;
   private static final int FIELD_HEIGHT = 30;
   private static final Dimension FIELD_MINIMUM_DIMENSION = new Dimension(FIELD_WIDTH,
-      FIELD_HEIGHT * 3);
+      FIELD_HEIGHT);
   private static final Dimension LABEL_MINIMUM_DIMENSION = new Dimension(LABEL_WIDTH, FIELD_HEIGHT);
-  private static final String ADD = "add";
-  private static final String DELETE = "delete";
-  private static final String CLEAR = "clear";
-
-  private static final Border ERROR_BORDER = BorderFactory.createLineBorder(Color.RED, 1);
   private static final Border DEFAULT_BORDER = new JTextField().getBorder();
-
+  private static final String SAVE = "SAVE";
+  private static final String VALIDATE = "VALIDATE";
+  private static final String CANCEL = "CANCEL";
+  private final JLabel helper = new ThemedIconLabel("help.png");
   private JButton saveButton;
-
-  private PlaceHolderTextField templateIdField;
-  private PlaceHolderTextField templateVersionField;
-  private PlaceHolderTextField templateAuthorField;
-  private PlaceHolderTextField templateUrlField;
-
-  private JTextArea templateDescriptionField;
-  private JTextArea templateChangesField;
-
-  private JLabel idValidation;
+  private JButton cancelButton;
+  private JComboBox<CorrelationTemplatesRepository> repositoriesComboBox;
+  private PlaceHolderComboBox protocolsComboBox;
+  private JComboBox<String> existingVersionsComboBox;
+  private PlaceHolderTextField newVersionTextField;
+  private PlaceHolderTextField authorTextField;
+  private PlaceHolderTextField urlTextField;
+  private JTextArea descriptionTextArea;
+  private JTextArea changesTextArea;
+  private TemplateDependenciesTable dependenciesTable;
+  private JLabel protocolValidation;
   private JLabel versionValidation;
   private JLabel authorValidation;
   private JLabel urlValidation;
   private JLabel descriptionValidation;
   private JLabel changesValidation;
-
   private BufferedImage templateSnapshot;
-  private ObjectTableModel dependencyModel;
-  private JTable dependenciesTable;
-
   private CollapsiblePanel dependenciesCollapsiblePanel;
+  private final HashMap<String, CorrelationTemplatesRepository> repositoriesMap = new HashMap<>();
+  private CorrelationTemplatesRegistryHandler templatesRegistry;
+  private CorrelationTemplatesRepositoriesRegistryHandler repositoriesRegistry;
+  private Consumer<Template> updateLastTemplateSupplier;
+  private HelperDialog helperDialog;
+
+  private Map<String, String> repositoryIdToName = new HashMap<>();
+
+  private JTabbedPane tabbedPane = new JTabbedPane();
+
+  private ValidationManager manager = new ValidationManager();
+  private Template loadedTemplate;
 
   public TemplateSaveFrame(CorrelationTemplatesRegistryHandler templatesRegistry,
-                           BufferedImage snapshot,
-                           Consumer<Template> updateLastTemplateSupplier,
+                           CorrelationTemplatesRepositoriesRegistryHandler repositoriesRegistry,
+                           BufferedImage snapshot, Consumer<Template> updateLastTemplateSupplier,
                            JPanel parent) {
-    super((JFrame) SwingUtilities.getWindowAncestor(parent), true);
+    super((JFrame) SwingUtilities.getWindowAncestor(parent), false);
     setTitle("Correlation Template");
     setName("correlationTemplateFrame");
-    buildMainPanel(templatesRegistry);
-    templateSnapshot = snapshot;
-    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
-    saveButton.addActionListener(
-        createSaveTemplateActionListener(templatesRegistry, updateLastTemplateSupplier));
-    pack();
-  }
+    this.templateSnapshot = snapshot;
+    this.templatesRegistry = templatesRegistry;
+    this.repositoriesRegistry = repositoriesRegistry;
+    this.updateLastTemplateSupplier = updateLastTemplateSupplier;
 
-  private void buildMainPanel(CorrelationTemplatesRegistryHandler templatesRegistry) {
-    saveButton = SwingUtils.createComponent("saveTemplateButton", new JButton("Save"));
+    buildMainPanel();
+    setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+    dependenciesTable.setTemplatesRegistry(templatesRegistry);
     saveButton.setEnabled(false);
-    saveButton.setToolTipText("Fill the field before saving");
+    getRootPane().registerKeyboardAction(e -> closeDialog(),
+        KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0),
+        JComponent.WHEN_IN_FOCUSED_WINDOW);
 
-    templateIdField = makePlaceHolderTextField("correlationTemplateIdField",
-        "Unique identifier");
-    templateVersionField = makePlaceHolderTextField("correlationTemplateVersionField",
-        "1.0, 2.0-Beta, etc.");
-    templateAuthorField = makePlaceHolderTextField("correlationTemplateAuthorField",
-        "Owner, user, GitHub user, etc.");
-    templateUrlField = makePlaceHolderTextField("correlationTemplateUrlField",
-        "Url repository/example@email.com");
+    addWindowListener(new WindowAdapter() {
+      @Override
+      public void windowClosing(WindowEvent e) {
+        closeDialog();
+        super.windowClosing(e);
+      }
+    });
 
-    templateDescriptionField = new JTextArea(3, 10);
-    templateDescriptionField.setName("correlationTemplateDescriptionTextArea");
-    templateDescriptionField.setBorder(BorderFactory.createEmptyBorder());
+    TemplateSaveFrame currJDialog = this;
+    addComponentListener(new ComponentAdapter() {
+      public void componentResized(ComponentEvent e) {
+        ComponentUtil.centerComponentInWindow(currJDialog);
+      }
+    });
 
-    templateChangesField = new JTextArea(3, 10);
-    templateChangesField.setName("correlationTemplateChangesField");
-    templateChangesField.setBorder(BorderFactory.createEmptyBorder());
+    pack();
+  }
 
-    addFieldsValidations(templatesRegistry);
+  private void closeDialog() {
+    manager.resetAll();
+    tabbedPane.setSelectedIndex(0);
+    dispose();
+  }
 
-    JLabel idLabel = makeLabel("ID *:");
-    JLabel descriptionLabel = makeLabel("Description *:");
-    JLabel authorLabel = makeLabel("Author *:");
-    JLabel urlLabel = makeLabel("URL/Email:");
-    JLabel changesLabel = makeLabel("Changes *: ");
-    JLabel versionLabel = makeLabel("Version *: ");
-    JLabel descriptionInfo = makeLabel("This field allows HTML tags.");
-    descriptionInfo.setFont(descriptionInfo.getFont().deriveFont(Font.ITALIC));
-    JLabel asteriskInfo = makeLabel("All fields marked with * are required");
-    asteriskInfo.setFont(asteriskInfo.getFont().deriveFont(Font.ITALIC));
+  private void buildMainPanel() {
+    initElements();
+    addValidations();
 
-    JScrollPane descriptionScrollPane = new JScrollPane(templateDescriptionField);
-    descriptionScrollPane.setBorder(DEFAULT_BORDER);
-    descriptionScrollPane.setBackground(templateDescriptionField.getBackground());
+    tabbedPane.setName("tabbedPane");
+    tabbedPane.addTab("Version Information", createCommonEditableFieldsPanel());
+    tabbedPane.addTab("Template Information", createTemplateDescriptionPanel());
 
-    JScrollPane changesScrollPane = new JScrollPane(templateChangesField);
-    changesScrollPane.setBorder(DEFAULT_BORDER);
-    changesScrollPane.setBackground(templateChangesField.getBackground());
+    JPanel buttonPanel = new JPanel();
+    buttonPanel.setName("buttonPanel");
+    GroupLayout buttonLayout = new GroupLayout(buttonPanel);
+    buttonPanel.setLayout(buttonLayout);
 
-    dependenciesCollapsiblePanel = buildDependenciesPanel();
+    buttonLayout.setHorizontalGroup(buttonLayout.createSequentialGroup()
+        .addComponent(saveButton)
+        .addComponent(cancelButton));
 
-    JPanel mainPanel = SwingUtils.createComponent("correlationTemplatePanel", new JPanel());
-    GroupLayout layout = new GroupLayout(mainPanel);
-    layout.setAutoCreateContainerGaps(true);
-    layout.setAutoCreateGaps(true);
-    mainPanel.setLayout(layout);
-    mainPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
-    layout.setHorizontalGroup(layout.createParallelGroup()
-        .addGroup(layout.createSequentialGroup()
-            .addGroup(layout.createParallelGroup()
-                .addComponent(asteriskInfo)))
-        .addGroup(layout.createSequentialGroup()
-            .addComponent(idLabel)
-            .addGroup(layout.createParallelGroup()
-                .addComponent(templateIdField)
-                .addComponent(idValidation)))
-        .addGroup(layout.createSequentialGroup()
-            .addComponent(versionLabel)
-            .addGroup(layout.createParallelGroup()
-                .addComponent(templateVersionField)
-                .addComponent(versionValidation)))
-        .addGroup(layout.createSequentialGroup()
-            .addComponent(authorLabel)
-            .addGroup(layout.createParallelGroup()
-                .addComponent(templateAuthorField)
-                .addComponent(authorValidation)))
-        .addGroup(layout.createSequentialGroup()
-            .addComponent(urlLabel)
-            .addGroup(layout.createParallelGroup()
-                .addComponent(templateUrlField)
-                .addComponent(urlValidation)))
+    buttonLayout.setVerticalGroup(buttonLayout.createSequentialGroup()
+        .addGroup(buttonLayout.createParallelGroup(Alignment.CENTER)
+            .addComponent(saveButton)
+            .addComponent(cancelButton)));
+
+    JLabel information = new JLabel("Saving your current version of the Template");
+
+    JPanel base = SwingUtils.createComponent("basePanel", new JPanel());
+    GroupLayout layout = SwingUtils.createGroupLayout(base);
+
+    layout.setHorizontalGroup(layout.createParallelGroup(Alignment.LEADING)
         .addGroup(layout.createSequentialGroup()
-            .addGroup(layout.createParallelGroup()
-                .addComponent(descriptionLabel)
-                .addComponent(descriptionScrollPane)
-                .addComponent(descriptionInfo)
-                .addComponent(descriptionScrollPane)
-                .addComponent(descriptionValidation)))
+            .addComponent(information)
+            .addComponent(helper))
         .addGroup(layout.createSequentialGroup()
-            .addGroup(layout.createParallelGroup()
-                .addComponent(changesLabel)
-                .addComponent(changesScrollPane)
-                .addComponent(changesValidation)))
+            .addComponent(tabbedPane))
         .addGroup(layout.createSequentialGroup()
-            .addComponent(dependenciesCollapsiblePanel))
-        .addComponent(saveButton, Alignment.CENTER)
-    );
+            .addComponent(buttonPanel)));
 
-    //JTextField have max height to keep JMeter's consistency forms
     layout.setVerticalGroup(layout.createSequentialGroup()
+        .addGroup(layout.createParallelGroup(Alignment.CENTER)
+            .addComponent(information)
+            .addComponent(helper))
+        .addGap(10)
+        .addComponent(tabbedPane)
+        .addComponent(buttonPanel));
+
+    add(base);
+  }
+
+  private JPanel createCommonEditableFieldsPanel() {
+    JLabel repositoryLabel = makeLabel("Repository *:");
+    JLabel templateLabel = makeLabel("Template *:");
+    JLabel versionLabel = makeLabel("Version:");
+    JLabel proposedLabel = makeLabel("New Version *:");
+    JLabel changesLabel = makeLabel("Changes *:");
+
+    JPanel fieldsPanel = new JPanel();
+    fieldsPanel.setName("fieldsPanel");
+
+    GroupLayout layout = SwingUtils.createGroupLayout(fieldsPanel);
+
+    layout.setHorizontalGroup(layout.createSequentialGroup()
         .addGroup(layout.createParallelGroup()
-            .addComponent(asteriskInfo))
-        .addGroup(layout.createParallelGroup()
-            .addComponent(idLabel)
-            .addGroup(layout.createSequentialGroup()
-                .addComponent(templateIdField, FIELD_HEIGHT, FIELD_HEIGHT, FIELD_HEIGHT)
-                .addComponent(idValidation)))
-        .addGroup(layout.createParallelGroup()
-            .addComponent(versionLabel)
-            .addGroup(layout.createSequentialGroup()
-                .addComponent(templateVersionField, FIELD_HEIGHT, FIELD_HEIGHT, FIELD_HEIGHT)
-                .addComponent(versionValidation)))
-        .addGroup(layout.createParallelGroup()
-            .addComponent(authorLabel)
-            .addGroup(layout.createSequentialGroup()
-                .addComponent(templateAuthorField, FIELD_HEIGHT, FIELD_HEIGHT, FIELD_HEIGHT)
-                .addComponent(authorValidation)))
-        .addGroup(layout.createParallelGroup()
-            .addComponent(urlLabel)
-            .addGroup(layout.createSequentialGroup()
-                .addComponent(templateUrlField, FIELD_HEIGHT, FIELD_HEIGHT, FIELD_HEIGHT)
-                .addComponent(urlValidation)))
+            .addComponent(repositoryLabel)
+            .addComponent(versionLabel))
         .addGroup(layout.createParallelGroup()
-            .addGroup(layout.createSequentialGroup()
-                .addComponent(descriptionLabel)
-                .addComponent(descriptionInfo)
-                .addComponent(descriptionScrollPane)
-                .addComponent(descriptionValidation)))
+            .addComponent(repositoriesComboBox)
+            .addComponent(existingVersionsComboBox))
         .addGroup(layout.createParallelGroup()
-            .addGroup(layout.createSequentialGroup()
-                .addComponent(changesLabel)
-                .addComponent(changesScrollPane)
-                .addComponent(changesValidation)))
+            .addComponent(templateLabel)
+            .addComponent(proposedLabel))
         .addGroup(layout.createParallelGroup()
-            .addComponent(dependenciesCollapsiblePanel))
-        .addGap(FIELD_HEIGHT, FIELD_HEIGHT, FIELD_HEIGHT)
-        .addComponent(true, saveButton)
-    );
-    add(mainPanel);
-  }
+            .addComponent(protocolsComboBox)
+            .addComponent(protocolValidation)
+            .addComponent(newVersionTextField)
+            .addComponent(versionValidation)));
 
-  private PlaceHolderTextField makePlaceHolderTextField(String name, String placeHolderText) {
-    PlaceHolderTextField field = SwingUtils.createComponent(name, new PlaceHolderTextField(),
-        FIELD_MINIMUM_DIMENSION);
-    field.setPlaceHolder(placeHolderText);
-    return field;
-  }
+    layout.setVerticalGroup(layout.createSequentialGroup()
+        .addGroup(layout.createParallelGroup(Alignment.BASELINE)
+            .addComponent(repositoryLabel)
+            .addComponent(repositoriesComboBox)
+            .addComponent(templateLabel)
+            .addComponent(protocolsComboBox, 0, FIELD_HEIGHT, FIELD_HEIGHT))
+        .addGroup(layout.createParallelGroup(Alignment.BASELINE)
+            .addComponent(protocolValidation))
+        .addGroup(layout.createParallelGroup(Alignment.BASELINE)
+            .addComponent(versionLabel)
+            .addComponent(existingVersionsComboBox)
+            .addComponent(proposedLabel)
+            .addComponent(newVersionTextField))
+        .addGroup(layout.createParallelGroup(Alignment.BASELINE)
+            .addComponent(versionValidation)));
+
+    JScrollPane changesScrollPane = createScrollPane(changesTextArea);
+
+    JPanel changesPanel = SwingUtils.createComponent("changesPanel", new JPanel());
+    GroupLayout changesLayout = SwingUtils.createGroupLayout(changesPanel);
+
+    changesLayout.setHorizontalGroup(changesLayout.createParallelGroup()
+        .addComponent(changesLabel)
+        .addComponent(changesScrollPane)
+        .addComponent(changesValidation));
 
-  private void addFieldsValidations(
-      CorrelationTemplatesRegistryHandler templatesRegistry) {
-    //Value cant be empty
-    Validation isEmpty = new Validation(text -> text.trim().isEmpty(), "This field can't be empty");
+    changesLayout.setVerticalGroup(changesLayout.createSequentialGroup()
+        .addComponent(changesLabel)
+        .addComponent(changesScrollPane, FIELD_HEIGHT * 2, FIELD_HEIGHT * 3, FIELD_HEIGHT * 4)
+        .addComponent(changesValidation));
 
-    //Value can't have special characters
-    Validation hasInvalidCharacters = new Validation(text ->
-        Pattern.compile("[^a-zA-Z0-9\\-_.]").matcher(text).find(), "Use only alphanumeric values "
-        + "and dashes (- and _).");
+    JLabel informationLabel = new JLabel("Select the repository, template, and template version");
 
-    //Only will be tested if the previous validations pass. Version has to be unique
-    Validation isRepeatedVersion = new Validation(version ->
-        templatesRegistry.isLocalTemplateVersionSaved(getTemplateID(), version),
-        "This %s is already in use");
+    JPanel panel = SwingUtils.createComponent("currentVersionPanel", new JPanel());
+    GroupLayout groupLayout = SwingUtils.createGroupLayout(panel);
 
-    idValidation = makeValidationLabel("idValidation");
+    groupLayout.setHorizontalGroup(groupLayout.createParallelGroup()
+        .addComponent(informationLabel)
+        .addComponent(fieldsPanel)
+        .addComponent(changesPanel));
+
+    groupLayout.setVerticalGroup(groupLayout.createSequentialGroup()
+        .addComponent(informationLabel)
+        .addComponent(fieldsPanel)
+        .addComponent(changesPanel));
+
+    return panel;
+  }
+
+  private void initElements() {
+    protocolValidation = makeValidationLabel("idValidation");
     versionValidation = makeValidationLabel("versionValidation");
     authorValidation = makeValidationLabel("authorValidation");
     urlValidation = makeValidationLabel("urlValidation");
     descriptionValidation = makeValidationLabel("descriptionValidation");
     changesValidation = makeValidationLabel("changesValidation");
 
-    addFieldValidations("Id", templateIdField, idValidation, isEmpty, hasInvalidCharacters);
-    addFieldValidations("Version", templateVersionField, versionValidation, isEmpty,
-        hasInvalidCharacters, isRepeatedVersion);
-    addFieldValidations("Author", templateAuthorField, authorValidation, isEmpty);
-    addFieldValidations("Description", templateDescriptionField, descriptionValidation, isEmpty);
-    addFieldValidations("Changes", templateChangesField, changesValidation, isEmpty);
+    repositoriesComboBox = createComboBox("repositoriesComboBox");
+    repositoriesComboBox.setRenderer(new RepositoryCellRender());
+
+    protocolsComboBox = new PlaceHolderComboBox();
+    protocolsComboBox.setPreferredSize(new Dimension(300, FIELD_HEIGHT));
+
+    existingVersionsComboBox = createComboBox("templateVersionComboBox");
+
+    changesTextArea = createTextArea("templateChangesTextArea");
+    descriptionTextArea = createTextArea("correlationTemplateDescriptionTextArea");
+
+    authorTextField = makePlaceHolderTextField("correlationTemplateAuthorField",
+        "Owner, user, GitHub user, etc.");
+    urlTextField = makePlaceHolderTextField("correlationTemplateUrlField",
+        "Url repository/example@email.com");
+    newVersionTextField = makePlaceHolderTextField("templateSuggestedVersionField",
+        "1, 1.2, 2.0.1, etc.");
+
+    repositoriesComboBox.addActionListener(e -> {
+      CorrelationTemplatesRepository selectedRepo =
+          (CorrelationTemplatesRepository) repositoriesComboBox.getSelectedItem();
+      if (selectedRepo != null) {
+        protocolsComboBox.setTemplates(new ArrayList<>(selectedRepo.getTemplates().values()));
+      } else {
+        protocolsComboBox.resetToDefault();
+      }
+      refreshExistingVersions();
+    });
+
+    protocolsComboBox.addActionListener(e -> refreshExistingVersions());
+    protocolsComboBox.addEditorLostFocusListener(e -> refreshExistingVersions());
+    existingVersionsComboBox.addActionListener(e -> updateProposedVersion());
+
+    SwingUtils.ButtonBuilder builder = new SwingUtils.ButtonBuilder()
+        .withActionListener(this)
+        .isEnabled(true);
+
+    saveButton = builder
+        .withAction(SAVE)
+        .withName("saveTemplateButton")
+        .withText("Save")
+        .withToolTip("Save the current template")
+        .build();
+
+    cancelButton = builder
+        .withAction(CANCEL)
+        .withName("cancelTemplateButton")
+        .withText("Cancel")
+        .withToolTip("Return to the main window")
+        .build();
+
+    String descriptionFile = DescriptionContent.getFromClass(this.getClass());
+    helper.setName("helperIcon");
+    helper.setToolTipText("Get more information");
+    helper.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
+    Dimension helperDimension = new Dimension(35, 35);
+    helper.setPreferredSize(helperDimension);
+    helper.setSize(helperDimension);
+    helper.addMouseListener(new MouseAdapter() {
+      @Override
+      public void mouseClicked(MouseEvent mouseEvent) {
+        helperDialog = new HelperDialog(TemplateSaveFrame.this);
+        helperDialog.setName("helperDialog");
+        helperDialog.setTitle("Repository Manager Information");
+        helperDialog.updateDialogContent(descriptionFile);
+        helperDialog.setVisible(true);
+        helperDialog.updateDialogContent(descriptionFile);
+      }
+    });
+  }
+
+  private void loadFormData() {
+    loadRepositoriesNames(repositoriesRegistry.getCorrelationRepositories());
+    clearNonSavedRepository();
+
+    repositoriesComboBox.removeAllItems();
+    repositoriesMap.forEach((key, value) -> repositoriesComboBox.addItem(value));
+
+    if (loadedTemplate == null) {
+      selectLocalRepository();
+    } else {
+      loadDataFromTemplate();
+    }
+  }
+
+  private void loadDataFromTemplate() {
+    repositoriesComboBox.setSelectedItem(repositoriesMap.get(loadedTemplate.getRepositoryId()));
+    setProtocol(loadedTemplate.getId());
+    existingVersionsComboBox.setSelectedItem(loadedTemplate.getVersion());
+    descriptionTextArea.setText(loadedTemplate.getDescription());
+    authorTextField.setText(loadedTemplate.getAuthor());
+    urlTextField.setText(loadedTemplate.getUrl());
+    setDependencies(loadedTemplate.getDependencies());
+  }
+
+  private void refreshExistingVersions() {
+    existingVersionsComboBox.removeAllItems();
+    protocolsComboBox.getSelectedTemplateVersions().forEach(existingVersionsComboBox::addItem);
+    existingVersionsComboBox.setSelectedIndex(0);
+    refreshProposedNewVersion((String) existingVersionsComboBox.getSelectedItem());
+  }
+
+  private void loadRepositoriesNames(List<CorrelationTemplatesRepository> repositories) {
+    repositoriesMap.clear();
+    repositories.forEach(repository -> repositoriesMap.put(repository.getName(), repository));
+  }
+
+  private void clearNonSavedRepository() {
+    // If the repository with String "central" exists in repositoriesMap, remove it
+    if (repositoriesMap.containsKey("central")) {
+      repositoriesMap.remove("central");
+    }
+
+    if (repositoriesMap.containsKey("bzm-central")) {
+      repositoriesMap.remove("bzm-central");
+    }
+  }
+
+  private static JTextArea createTextArea(String name) {
+    JTextArea textArea = new JTextArea(5, 10);
+    textArea.setName(name);
+    textArea.setBorder(BorderFactory.createEmptyBorder());
+    return textArea;
+  }
+
+  private static JScrollPane createScrollPane(JTextArea textArea) {
+    JScrollPane scrollPane = new JScrollPane(textArea);
+    scrollPane.setBorder(DEFAULT_BORDER);
+    scrollPane.setBackground(textArea.getBackground());
+    return scrollPane;
+  }
+
+  private static boolean isManuallyEditing(Object selectedProtocol) {
+    return selectedProtocol == null || !(selectedProtocol instanceof CorrelationTemplateVersions);
+  }
+
+  private void refreshProposedNewVersion(String initialVersion) {
+    String nextVersion = VersionUtils.getNextProposedPatch(initialVersion);
+    newVersionTextField.setText(nextVersion);
+  }
+
+  private JComboBox createComboBox(String name) {
+    return SwingUtils.createComponent(name, new JComboBox<>());
+  }
+
+  private void updateProposedVersion() {
+    String baseVersion = (String) existingVersionsComboBox.getSelectedItem();
+    if (baseVersion == null) {
+      return;
+    }
+
+    refreshProposedNewVersion(baseVersion);
+  }
+
+  private JPanel createTemplateDescriptionPanel() {
+    JLabel templateDescriptionLabel = new JLabel("Template's description (this field allows "
+        + "HTML tags)");
+
+    JScrollPane descriptionScrollPane = createScrollPane(descriptionTextArea);
+
+    JPanel templateDescriptionPanel = SwingUtils.createComponent("templateDescriptionPanel",
+        new JPanel());
+    GroupLayout groupLayout = SwingUtils.createGroupLayout(templateDescriptionPanel);
+
+    groupLayout.setHorizontalGroup(groupLayout.createParallelGroup()
+        .addComponent(templateDescriptionLabel)
+        .addComponent(descriptionScrollPane)
+        .addComponent(descriptionValidation));
+
+    groupLayout.setVerticalGroup(groupLayout.createSequentialGroup()
+        .addComponent(templateDescriptionLabel)
+        .addComponent(descriptionScrollPane, FIELD_HEIGHT, FIELD_HEIGHT * 2, FIELD_HEIGHT * 3)
+        .addComponent(descriptionValidation));
+
+    JPanel authorDetailsPanel = SwingUtils.createComponent("authorDetailsPanel", new JPanel());
+    GroupLayout layout = SwingUtils.createGroupLayout(authorDetailsPanel);
+
+    JLabel authorLabel = new JLabel("Author's Name:");
+    JLabel authorEmailLabel = new JLabel("Author's Email:");
+
+    // Add the elements so each label appears at the left of the TextField and the Validation
+    // labels appear under the TextField
+    layout.setHorizontalGroup(layout.createSequentialGroup()
+        .addGroup(layout.createParallelGroup()
+            .addComponent(authorLabel)
+            .addComponent(authorEmailLabel))
+        .addGroup(layout.createParallelGroup()
+            .addComponent(authorTextField)
+            .addComponent(authorValidation)
+            .addComponent(urlTextField)
+            .addComponent(urlValidation)));
+
+    layout.setVerticalGroup(layout.createSequentialGroup()
+        .addGroup(layout.createParallelGroup(Alignment.BASELINE)
+            .addComponent(authorLabel)
+            .addComponent(authorTextField))
+        .addGroup(layout.createParallelGroup(Alignment.BASELINE)
+            .addComponent(authorValidation))
+        .addGroup(layout.createParallelGroup(Alignment.BASELINE)
+            .addComponent(authorEmailLabel)
+            .addComponent(urlTextField))
+        .addGroup(layout.createParallelGroup(Alignment.BASELINE)
+            .addComponent(urlValidation)));
+
+    dependenciesCollapsiblePanel = buildDependenciesPanel();
+
+    JPanel templateInformationPanel = SwingUtils.createComponent("templateInformationPanel",
+        new JPanel());
+    GroupLayout templateInformationLayout = SwingUtils.createGroupLayout(templateInformationPanel);
+
+    templateInformationLayout.setHorizontalGroup(
+        templateInformationLayout.createParallelGroup()
+            .addComponent(templateDescriptionPanel)
+            .addComponent(authorDetailsPanel)
+            .addComponent(dependenciesCollapsiblePanel));
+
+    templateInformationLayout.setVerticalGroup(
+        templateInformationLayout.createSequentialGroup()
+            .addComponent(templateDescriptionPanel)
+            .addComponent(authorDetailsPanel)
+            .addComponent(dependenciesCollapsiblePanel));
+
+    return templateInformationPanel;
+  }
+
+  private PlaceHolderTextField makePlaceHolderTextField(String name, String placeHolderText) {
+    PlaceHolderTextField field = SwingUtils.createComponent(name, new PlaceHolderTextField(),
+        new Dimension(150, 30));
+    field.setMaximumSize(FIELD_MINIMUM_DIMENSION);
+    field.setPlaceHolder(placeHolderText);
+    return field;
+  }
+
+  private JTextField getProtocolsContentField() {
+    return (JTextField) protocolsComboBox.getEditor().getEditorComponent();
   }
 
   private JLabel makeValidationLabel(String labelName) {
     JLabel label = makeLabel("");
     label.setName(labelName);
-    label.setVisible(false);
+    label.setVisible(true);
     label.setForeground(Color.RED);
     return label;
   }
 
-  public void addFieldValidations(String id, JTextComponent field, JLabel errorDisplay,
-                                  Validation... validations) {
-    field.addFocusListener(new FocusAdapter() {
-      @Override
-      public void focusLost(FocusEvent e) {
-        Optional<Validation> failingValidation = Arrays.stream(validations)
-            .filter(v -> v.failsValidation(field.getText()))
-            .findFirst();
-        boolean failsValidation = failingValidation.isPresent();
-        updateComponentValidationStyle(field, errorDisplay, failsValidation);
-        errorDisplay.setText(failsValidation ? failingValidation.get().formatErrorMessage(id) : "");
-        validateForm();
-        pack();
-        super.focusLost(e);
-      }
-    });
+  private void addValidations() {
+    UniqueVersionCondition uniqueVersionCondition = new UniqueVersionCondition();
+    uniqueVersionCondition.setVersionsSupplier(
+        () -> protocolsComboBox.getSelectedTemplateVersions());
+
+    NotEmptyCondition emptyCondition = new NotEmptyCondition();
+
+    List<Condition> nonEmptyCondition = Collections.singletonList(emptyCondition);
+    List<Condition> versionConditions = Arrays.asList(emptyCondition, uniqueVersionCondition);
+
+    JTextField protocolTextField = getProtocolsContentField();
+    manager.register(protocolTextField, protocolValidation, nonEmptyCondition);
+    manager.register(newVersionTextField, versionValidation, versionConditions);
+    manager.register(changesTextArea, changesValidation, nonEmptyCondition);
+    manager.register(descriptionTextArea, descriptionValidation, nonEmptyCondition);
+    manager.register(authorTextField, authorValidation, nonEmptyCondition);
+    manager.register(urlTextField, urlValidation, nonEmptyCondition);
+
+    manager.setSaveButton(saveButton);
+    manager.setAfterValidation(this::refreshWindow);
+  }
+
+  public void refreshWindow() {
+    repaint();
+    pack();
   }
 
   private void updateComponentValidationStyle(JTextComponent field, JLabel errorDisplay,
                                               boolean hasFailedValidation) {
-    //JTextArea are contained in JScroll's JView point, need to get 2 parent levels
-    (field instanceof JTextField ? field : (JScrollPane) field.getParent().getParent())
-        .setBorder(hasFailedValidation ? ERROR_BORDER : DEFAULT_BORDER);
+    Color defaultBackgroundColor = UIManager.getColor("TextField.background");
+    Color background = hasFailedValidation ? Color.PINK : defaultBackgroundColor;
+    if (field instanceof JTextField) {
+      field.setBackground(background);
+    } else if (field instanceof JTextArea) {
+      field.setBackground(background);
+      Container viewPortContainer = field.getParent();
+      viewPortContainer.setBackground(background);
+      Container scrollContainer = viewPortContainer.getParent();
+      if (scrollContainer != null) {
+        scrollContainer.setBackground(background);
+      }
+    } else if (field instanceof PlaceHolderTextField) {
+      field.setBackground(background);
+    }
     errorDisplay.setVisible(hasFailedValidation);
   }
 
   private void validateForm() {
-    boolean formIsInvalid =
-        idValidation.isVisible() || versionValidation.isVisible() || descriptionValidation
-            .isVisible() || changesValidation.isVisible() || authorValidation.isVisible();
+    boolean formIsInvalid = Stream.of(protocolValidation, versionValidation, authorValidation,
+            urlValidation, descriptionValidation, changesValidation)
+        .anyMatch(validation -> validation.isVisible());
     saveButton.setEnabled(!formIsInvalid);
-    saveButton
-        .setToolTipText(formIsInvalid ? "Please correct the issues in red before proceed" : "");
+    saveButton.setToolTipText(formIsInvalid ? "Please correct the issues in red before proceed"
+        : "");
   }
 
   private JLabel makeLabel(String text) {
@@ -329,8 +599,8 @@ private JLabel makeLabel(String text) {
   }
 
   private CollapsiblePanel buildDependenciesPanel() {
-    JPanel dependenciesBody = prepareDependenciesPanel();
-    dependenciesBody.setPreferredSize(new Dimension(300, 200));
+    dependenciesTable = new TemplateDependenciesTable();
+    JPanel dependenciesBody = dependenciesTable.prepareDependenciesPanel();
     /*
      * Since some L&F won't allow to cast LineBorder over the JTextField border to
      * obtain the color, we use the default border as it is (won't remove the top).
@@ -358,209 +628,43 @@ private void onCollapseResize() {
     setSize(finalSize);
   }
 
-  private JPanel prepareDependenciesPanel() {
-    JPanel templateDependenciesButtonsPanel = buildDependencyButtonPanel();
-    JLabel dependencyOverwriteLabel = new JLabel("Repeated dependencies will be overwritten.");
-    dependencyOverwriteLabel.setPreferredSize(new Dimension(300, 30));
-    JScrollPane templateDependenciesScroll = prepareDependenciesTable();
-    templateDependenciesScroll.setPreferredSize(new Dimension(300, 200));
-
-    JPanel dependenciesPanel = new JPanel();
-    GroupLayout dependenciesLayout = new GroupLayout(dependenciesPanel);
-    dependenciesPanel.setLayout(dependenciesLayout);
-
-    dependenciesLayout.setHorizontalGroup(dependenciesLayout.createParallelGroup()
-        .addComponent(templateDependenciesScroll)
-        .addComponent(dependencyOverwriteLabel, Alignment.CENTER)
-        .addComponent(templateDependenciesButtonsPanel)
-    );
-
-    dependenciesLayout.setVerticalGroup(dependenciesLayout.createSequentialGroup()
-        .addComponent(templateDependenciesScroll)
-        .addComponent(dependencyOverwriteLabel)
-        .addComponent(templateDependenciesButtonsPanel)
-    );
-
-    return dependenciesPanel;
-  }
-
-  private JScrollPane prepareDependenciesTable() {
-    dependencyModel = new ObjectTableModel(new String[] {"Name", "Version", "URL"},
-        CorrelationTemplateDependency.class,
-        new Functor[] {new Functor("getName"), new Functor("getVersion"), new Functor("getUrl")},
-        new Functor[] {new Functor("setName"), new Functor("setVersion"), new Functor("setUrl")},
-        new Class[] {String.class, String.class, String.class});
-
-    dependenciesTable = new JTable(dependencyModel);
-    dependenciesTable.setPreferredSize(new Dimension(300, 200));
-    dependenciesTable.setName("templateDependenciesScroll");
-    dependenciesTable.getColumnModel().getColumn(0).setPreferredWidth(50);
-    dependenciesTable.getColumnModel().getColumn(1).setPreferredWidth(50);
-    dependenciesTable.getColumnModel().getColumn(2).setPreferredWidth(200);
-    dependenciesTable.getTableHeader().setDefaultRenderer(new HeaderAsPropertyRenderer());
-    dependenciesTable.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
-    dependenciesTable.getTableHeader().setDefaultRenderer(new HeaderAsPropertyRenderer() {
-      @Override
-      protected String getText(Object value, int row, int column) {
-        return (value == null) ? "" : value.toString();
-      }
-    });
-    JMeterUtils.applyHiDPI(dependenciesTable);
-    JScrollPane pane = new JScrollPane(dependenciesTable);
-    pane.setName("templateDependenciesScroll");
-    pane.setPreferredSize(new Dimension(350, 150));
-    return pane;
-  }
-
-  private JPanel buildDependencyButtonPanel() {
-    SwingUtils.ButtonBuilder base = new SwingUtils.ButtonBuilder()
-        .withActionListener(this);
-
-    JButton deleteButton = base.withName("delete").withAction(DELETE).build();
-    JButton clearButton = base.withName("clear").withAction(CLEAR).build();
-
-    JPanel buttonPanel = new JPanel();
-    buttonPanel.setPreferredSize(new Dimension(300, 50));
-    buttonPanel.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10));
-    buttonPanel.add(base.withName("add").withAction(ADD).build());
-    buttonPanel.add(deleteButton);
-    buttonPanel.add(clearButton);
-    return buttonPanel;
-  }
-
   public void showFrame() {
+    clear();
+    loadFormData();
+    pack();
+    ComponentUtil.centerComponentInWindow(this);
     setVisible(true);
     requestFocus();
   }
 
   private String getTemplateID() {
-    return templateIdField.getText();
+    return " REMOVE THIS";
   }
 
   private String getVersion() {
-    return templateVersionField.getText();
+    return newVersionTextField.getText();
   }
 
   private String getAuthor() {
-    return templateAuthorField.getText();
+    return authorTextField.getText();
   }
 
   private String getUrl() {
-    return templateUrlField.getText();
-  }
-
-  private void close() {
-    this.dispose();
-  }
-
-  private ActionListener createSaveTemplateActionListener(
-      CorrelationTemplatesRegistryHandler templatesRegistry,
-      Consumer<Template> updateLastTemplateConsumer) {
-    return e -> {
-      //Left for the cases where the ID was changed after the version
-      if (isVersionRepeatedLocally(templatesRegistry)) {
-        JOptionPane.showMessageDialog(TemplateSaveFrame.this,
-            "There is already a version " + getVersion() + " installed. Please change it before "
-                + "continue",
-            "Save template error", JOptionPane.ERROR_MESSAGE);
-        return;
-      }
-
-      boolean hasRepeatedDependencies = false;
-      boolean hasFailingURLs = false;
-      List<CorrelationTemplateDependency> dependenciesList = new ArrayList<>();
-
-      if (dependencyModel.getRowCount() > 0) {
-        Iterator<CorrelationTemplateDependency> iterator =
-            (Iterator<CorrelationTemplateDependency>) dependencyModel
-                .iterator();
-
-        boolean allDependenciesComplete = true;
-        int dependencyIndex = 0;
-        while (iterator.hasNext()) {
-          dependencyIndex++;
-          CorrelationTemplateDependency dependency = iterator.next();
-          if (hasRowEmptyValues(dependency, dependencyIndex)) {
-            allDependenciesComplete = false;
-            continue;
-          }
-
-          List<CorrelationTemplateDependency> repeatedDependencies = dependenciesList.stream()
-              .filter(d -> d.getName().trim().toLowerCase()
-                  .equals(dependency.getName().trim().toLowerCase()))
-              .collect(Collectors.toList());
-
-          if (!repeatedDependencies.isEmpty()) {
-            hasRepeatedDependencies = true;
-            dependenciesList.removeAll(repeatedDependencies);
-          }
-
-          if (!templatesRegistry.isValidDependencyURL(dependency.getUrl(), dependency.getName(),
-              dependency.getVersion())) {
-            hasFailingURLs = true;
-            continue;
-          }
-
-          dependenciesList.add(dependency);
-        }
-
-        if (!allDependenciesComplete) {
-          JOptionPane.showMessageDialog(TemplateSaveFrame.this,
-              "There are incomplete dependencies. Fill or delete them before continue.");
-          return;
-        }
-      }
-
-      if (hasFailingURLs) {
-        JOptionPane.showMessageDialog(TemplateSaveFrame.this,
-            "There are some issues with some dependency's URLs, please fix then before continue"
-                + ".\nCheck the logs for more information.");
-        return;
-      }
-
-      if (hasRepeatedDependencies && JOptionPane.showConfirmDialog(TemplateSaveFrame.this,
-          "There are dependencies that are repeated. Want to overwrite them?",
-          "Saving Correlation Template",
-          JOptionPane.YES_NO_OPTION, JOptionPane.ERROR_MESSAGE) == JOptionPane.NO_OPTION) {
-        return;
-      }
-
-      Builder savingTemplateBuilder = new Builder()
-          .withId(getTemplateID())
-          .withVersion(getVersion())
-          .withAuthor(getAuthor())
-          .withUrl(getUrl())
-          .withDescription(templateDescriptionField.getText())
-          .withSnapshot(templateSnapshot)
-          .withRepositoryId(LOCAL_REPOSITORY_NAME)
-          .withChanges(templateChangesField.getText())
-          .withDependencies(dependenciesList);
-
-      try {
-        templatesRegistry.onSaveTemplate(savingTemplateBuilder);
-        updateLastTemplateConsumer.accept(savingTemplateBuilder.build());
-      } catch (IOException | ConfigurationException ex) {
-        JOptionPane
-            .showMessageDialog(TemplateSaveFrame.this,
-                "Error while trying to save template", "Save template error",
-                JOptionPane.ERROR_MESSAGE);
-        LOG.error("Error while trying to convert rules into json file {}", getTemplateID(), ex);
-      }
-      close();
-      clear();
-    };
+    return urlTextField.getText();
   }
 
   public void clear() {
-    clearField(templateIdField);
-    clearField(templateVersionField);
-    clearField(templateAuthorField);
-    clearField(templateUrlField);
-    clearField(templateDescriptionField);
-    clearField(templateChangesField);
-    saveButton.setEnabled(false);
-    clearTable();
     clearStyles();
+    clearField(changesTextArea);
+    clearField(descriptionTextArea);
+    clearField(authorTextField);
+    clearField(urlTextField);
+    dependenciesTable.clear();
+    saveButton.setEnabled(false);
+  }
+
+  public void selectLocalRepository() {
+    repositoriesComboBox.setSelectedItem(repositoriesMap.get(LOCAL_REPOSITORY_NAME));
   }
 
   private void clearField(JTextComponent field) {
@@ -569,38 +673,17 @@ private void clearField(JTextComponent field) {
         .setBorder(DEFAULT_BORDER);
   }
 
-  private void clearTable() {
-    dependencyModel.clearData();
-  }
-
   private void clearStyles() {
-    updateComponentValidationStyle(templateIdField, idValidation, false);
-    updateComponentValidationStyle(templateVersionField, versionValidation, false);
-    updateComponentValidationStyle(templateAuthorField, authorValidation, false);
-    updateComponentValidationStyle(templateUrlField, urlValidation, false);
-    updateComponentValidationStyle(templateDescriptionField, descriptionValidation, false);
-    updateComponentValidationStyle(templateChangesField, changesValidation, false);
-  }
-
-  private boolean hasRowEmptyValues(CorrelationTemplateDependency dependency, int dependencyIndex) {
-    boolean allFieldComplete = true;
-    if (isBlank(dependency.getName())) {
-      LOG.error("The dependency in the row {}, has no name.", dependencyIndex);
-      allFieldComplete = false;
-    }
-    if (isBlank(dependency.getUrl())) {
-      LOG.error("The dependency in the row {}, has no url.", dependencyIndex);
-      allFieldComplete = false;
-    }
-    if (isBlank(dependency.getVersion())) {
-      LOG.error("The dependency in the row {}, has no version.", dependencyIndex);
-      allFieldComplete = false;
-    }
-    return !allFieldComplete;
+    resetRepositoryDependantFields();
+    updateComponentValidationStyle(authorTextField, authorValidation, false);
+    updateComponentValidationStyle(urlTextField, urlValidation, false);
+    updateComponentValidationStyle(descriptionTextArea, descriptionValidation, false);
+    updateComponentValidationStyle(changesTextArea, changesValidation, false);
   }
 
-  public static boolean isBlank(String str) {
-    return str == null || str.trim().isEmpty();
+  private void resetRepositoryDependantFields() {
+    updateComponentValidationStyle(getProtocolsContentField(), protocolValidation, false);
+    updateComponentValidationStyle(newVersionTextField, versionValidation, false);
   }
 
   private boolean isVersionRepeatedLocally(CorrelationTemplatesRegistryHandler repositoryHandler) {
@@ -611,76 +694,162 @@ public void setTemplateSnapshot(BufferedImage snapshot) {
     this.templateSnapshot = snapshot;
   }
 
+  public void setDependencies(List<CorrelationTemplateDependency> dependencies) {
+    dependenciesTable.setDependencies(dependencies);
+  }
+
+  public void setLoadedTemplates(Template loadedTemplate) {
+    this.loadedTemplate = loadedTemplate;
+  }
+
+  public void setProtocol(String protocol) {
+    boolean protocolFound = false;
+    for (int i = 0; i < protocolsComboBox.getItemCount(); i++) {
+      CorrelationTemplateVersions template = protocolsComboBox.getItemAt(i);
+      if (template.getName().equals(protocol)) {
+        protocolsComboBox.setSelectedIndex(i);
+        protocolFound = true;
+        break;
+      }
+    }
+    if (!protocolFound) {
+      protocolsComboBox.setSelectedItem(protocol);
+    }
+  }
+
+  @VisibleForTesting
+  public TemplateDependenciesTable getDependenciesTable() {
+    return dependenciesTable;
+  }
+
   @Override
   public void actionPerformed(ActionEvent e) {
-    String action = e.getActionCommand();
-    switch (action) {
-      case ADD:
-        addRow();
+    String command = e.getActionCommand();
+    switch (command) {
+      case SAVE:
+        if (isValidForm()) {
+          saveTemplate();
+        }
         break;
-      case DELETE:
-        deleteRow();
+      case CANCEL:
+        closeDialog();
         break;
-      case CLEAR:
-        clearTable();
+      case VALIDATE:
+        validateForm();
         break;
       default:
-        LOG.warn("Unsupported action {}", action);
-        JMeterUtils
-            .reportErrorToUser("Unsupported action " + action, "Managing Repositories & Templates");
+        LOG.warn("Unknown action command: {}", command);
     }
   }
 
-  private void deleteRow() {
-    GuiUtils.cancelEditing(dependenciesTable);
+  private boolean isValidForm() {
+    dependenciesTable.validateDependencies();
+    if (dependenciesTable.isHasFailingURLs()) {
+      JOptionPane.showMessageDialog(TemplateSaveFrame.this,
+          "There are some issues with some dependency's URLs, please fix then before continue"
+              + ".\nCheck the logs for more information.");
+      return false;
+    }
 
-    int[] rowsSelected = dependenciesTable.getSelectedRows();
-    int anchorSelection = dependenciesTable.getSelectionModel().getAnchorSelectionIndex();
-    dependenciesTable.clearSelection();
-    if (rowsSelected.length > 0) {
-      for (int i = rowsSelected.length - 1; i >= 0; i--) {
-        dependencyModel.removeRow(rowsSelected[i]);
+    if (dependenciesTable.isHasRepeatedDependencies()) {
+      if (JOptionPane.showConfirmDialog(TemplateSaveFrame.this,
+          "There are dependencies that are repeated. Want to overwrite them?",
+          "Saving Correlation Template",
+          JOptionPane.YES_NO_OPTION, JOptionPane.ERROR_MESSAGE) == JOptionPane.NO_OPTION) {
+        return false;
       }
+    }
 
-      if (dependencyModel.getRowCount() > 0) {
-        if (anchorSelection >= dependencyModel.getRowCount()) {
-          anchorSelection = dependencyModel.getRowCount() - 1;
-        }
-        dependenciesTable.setRowSelectionInterval(anchorSelection, anchorSelection);
+    return true;
+  }
+
+  private void saveTemplate() {
+    Builder savingTemplateBuilder = new Builder()
+        .withId(getProtocolName())
+        .withRepositoryId(getRepositoryName())
+        .withVersion(getNewVersion())
+        .withChanges(getChanges())
+
+        .withDescription(getDescription())
+        .withAuthor(getAuthorName())
+        .withUrl(getAuthorEmail())
+        .withDependencies(getDependencies())
+        .withSnapshot(templateSnapshot);
+
+    boolean wasSuccessful = true;
+    String responseMessage = "Template saved successfully.";
+    try {
+      templatesRegistry.onSaveTemplate(savingTemplateBuilder);
+    } catch (IOException | ConfigurationException ex) {
+      responseMessage = "Error while trying to save template: " + ex.getMessage();
+      wasSuccessful = false;
+      LOG.error("Error while saving your template. Message: {}.", ex.getMessage());
+      return;
+    }
+
+    JOptionPane.showMessageDialog(TemplateSaveFrame.this,
+        responseMessage, "Save template",
+        JOptionPane.INFORMATION_MESSAGE);
+
+    if (wasSuccessful) {
+      updateLastTemplateSupplier.accept(savingTemplateBuilder.build());
+      closeDialog();
+    }
+  }
+
+  public static class RepositoryCellRender extends DefaultListCellRenderer {
+    @Override
+    public Component getListCellRendererComponent(JList<?> list,
+                                                  Object value,
+                                                  int index,
+                                                  boolean isSelected,
+                                                  boolean cellHasFocus) {
+
+      Component c =
+          super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+      CorrelationTemplatesRepository repository = (CorrelationTemplatesRepository) value;
+      if (repository != null) {
+        setText(repository.getDisplayName());
+      } else {
+        setText("None");
       }
+      return c;
     }
   }
 
-  private void addRow() {
-    GuiUtils.stopTableEditing(dependenciesTable);
-    dependencyModel.addRow(new CorrelationTemplateDependency());
-    int rowToSelect = dependenciesTable.getRowCount() - 1;
-    dependenciesTable.setRowSelectionInterval(rowToSelect, rowToSelect);
-    dependenciesTable.scrollRectToVisible(dependenciesTable.getCellRect(rowToSelect, 0, true));
+  private String getRepositoryName() {
+    return ((CorrelationTemplatesRepository) repositoriesComboBox.getSelectedItem()).getName();
   }
 
-  @VisibleForTesting
-  public List<CorrelationTemplateDependency> getDependencies() {
-    return (List<CorrelationTemplateDependency>) dependencyModel.getObjectList();
+  private String getProtocolName() {
+    return protocolsComboBox.getSelectedTemplate().getName();
   }
 
-  public void setDependencies(List<CorrelationTemplateDependency> dependencies) {
-    dependencies.forEach(d -> dependencyModel.addRow(d));
+  private String getNewVersion() {
+    return newVersionTextField.getText();
   }
 
-  public void setLoadedTemplates(Set<Template> loadedTemplates) {
-    clear();
-    //If we have more than 1 loaded template, we don't set this fields
-    if (loadedTemplates.size() == 1) {
-      Template loadedTemplate = loadedTemplates.iterator().next();
-      templateIdField.setText(loadedTemplate.getId());
-      templateAuthorField.setText(loadedTemplate.getAuthor());
-      templateUrlField.setText(loadedTemplate.getUrl());
-      templateVersionField.setText(loadedTemplate.getVersion());
-      templateDescriptionField.setText(loadedTemplate.getDescription());
-    }
-    loadedTemplates.stream()
-        .filter(t -> t.getDependencies() != null && !t.getDependencies().isEmpty())
-        .forEach(t -> setDependencies(t.getDependencies()));
+  private String getChanges() {
+    return changesTextArea.getText();
+  }
+
+  private String getAuthorName() {
+    return authorTextField.getText();
+  }
+
+  private String getAuthorEmail() {
+    return urlTextField.getText();
+  }
+
+  private String getDescription() {
+    return descriptionTextArea.getText();
+  }
+
+  private List<CorrelationTemplateDependency> getDependencies() {
+    return dependenciesTable.getDependencies();
+  }
+
+  private String getCurrentVersion() {
+    return (String) existingVersionsComboBox.getSelectedItem();
   }
 }
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplatesManagerFrame.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplatesManagerFrame.java
index b9669ac..e79eb2c 100644
--- a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplatesManagerFrame.java
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/TemplatesManagerFrame.java
@@ -103,8 +103,8 @@ public class TemplatesManagerFrame extends JDialog implements ActionListener {
   private JButton loadTemplate;
   private JButton refreshButton;
   private RepositoriesConfigFrame configFrame;
-
   private Map<Template, TemplateProperties> templatesProperties = new HashMap<>();
+  private Map<String, String> repositoryIdToName = new HashMap<>();
 
   public TemplatesManagerFrame(CorrelationTemplatesRegistryHandler templatesRegistryHandler,
                                CorrelationTemplatesRepositoriesRegistryHandler
@@ -217,7 +217,7 @@ public Component getListCellRendererComponent(JList<?> list, Object value, int i
         if (renderer instanceof JLabel && value instanceof TemplateManagerDisplay) {
           TemplateManagerDisplay templateManagerDisplay = (TemplateManagerDisplay) value;
           JLabel templateLabel = (JLabel) renderer;
-          templateLabel.setText(StringUtils.capitalize(templateManagerDisplay.getId()));
+          templateLabel.setText(templateManagerDisplay.getId());
         }
         return renderer;
       }
@@ -311,13 +311,15 @@ private void toggleVersionButtons(boolean installed) {
   private void updateTemplatesList(boolean useLocal) {
     Map<Template, TemplateProperties> rawTemplates = new HashMap<>();
 
-    for (CorrelationTemplatesRepository repository
-        : repositoriesRegistryHandler.getCorrelationRepositories()) {
+    List<CorrelationTemplatesRepository> repositories =
+        repositoriesRegistryHandler.getCorrelationRepositories();
+
+    for (CorrelationTemplatesRepository repository : repositories) {
+      repositoryIdToName.put(repository.getName(), repository.getDisplayName());
       Map<Template, TemplateProperties> templatesAndProperties =
           repositoriesRegistryHandler
               .getCorrelationTemplatesAndPropertiesByRepositoryName(
                   repository.getName(), useLocal);
-
       rawTemplates.putAll(templatesAndProperties);
     }
 
@@ -346,7 +348,7 @@ private DefaultListModel<TemplateManagerDisplay> unifyTemplates(
 
     Map<String, TemplateManagerDisplay> groupedTemplates = new HashMap<>();
     relatedTemplates.forEach(template -> {
-      String templateKey = template.getId() + " (" + template.getRepositoryId() + ")";
+      String templateKey = generateTemplateDisplayName(template);
       if (!groupedTemplates.containsKey(templateKey)) {
         groupedTemplates.put(templateKey,
             new TemplateManagerDisplay(templateKey, template.isInstalled()));
@@ -365,6 +367,10 @@ private DefaultListModel<TemplateManagerDisplay> unifyTemplates(
     return groupedTemplatesModel;
   }
 
+  private String generateTemplateDisplayName(Template template) {
+    return template.getId() + " (" + repositoryIdToName.get(template.getRepositoryId()) + ")";
+  }
+
   private void cacheImage(Template template) {
     if (template.getSnapshot() != null) {
       Dictionary cache = (Dictionary) templateInfoPane.getDocument()
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/Validation.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/Validation.java
deleted file mode 100644
index 25f17c2..0000000
--- a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/Validation.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package com.blazemeter.jmeter.correlation.gui.templates;
-
-import java.util.function.Predicate;
-
-public class Validation {
-
-  private final Predicate<String> condition;
-  private final String errorMessageTemplate;
-
-  public Validation(Predicate<String> condition, String errorMessageTemplate) {
-    this.condition = condition;
-    this.errorMessageTemplate = errorMessageTemplate;
-  }
-
-  public boolean failsValidation(String value) {
-    return condition.test(value);
-  }
-
-  public String formatErrorMessage(String owner) {
-    return String.format(errorMessageTemplate, owner);
-  }
-}
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/VersionUtils.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/VersionUtils.java
new file mode 100644
index 0000000..4f0b338
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/VersionUtils.java
@@ -0,0 +1,56 @@
+package com.blazemeter.jmeter.correlation.gui.templates;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
+
+public class VersionUtils {
+
+  public static int getNextMinor(List<String> versions) {
+    String latestVersion = getLatestVersion(versions);
+    DefaultArtifactVersion artifactVersion = new DefaultArtifactVersion(latestVersion);
+    return artifactVersion.getIncrementalVersion();
+  }
+
+  public static String getLatestVersion(List<String> versions) {
+    if (versions.isEmpty()) {
+      return "0.0.0";
+    }
+
+    List<DefaultArtifactVersion> artifactVersions = new ArrayList<>();
+
+    for (String version : versions) {
+      artifactVersions.add(new DefaultArtifactVersion(version));
+    }
+
+    Collections.sort(artifactVersions);
+
+    DefaultArtifactVersion latestArtifactVersion =
+        artifactVersions.get(artifactVersions.size() - 1);
+    return latestArtifactVersion.toString();
+  }
+
+  public static String getNextProposedMinor(List<String> versions) {
+    String latestVersion = getLatestVersion(versions);
+    DefaultArtifactVersion artifactVersion = new DefaultArtifactVersion(latestVersion);
+    int major = artifactVersion.getMajorVersion();
+    int minor = artifactVersion.getMinorVersion() + 1;
+    return major + "." + minor;
+  }
+
+  public static String getNextProposedMinor(String latestVersion) {
+    DefaultArtifactVersion artifactVersion = new DefaultArtifactVersion(latestVersion);
+    int major = artifactVersion.getMajorVersion();
+    int minor = artifactVersion.getMinorVersion() + 1;
+    return major + "." + minor;
+  }
+
+  public static String getNextProposedPatch(String latestVersion) {
+    DefaultArtifactVersion artifactVersion = new DefaultArtifactVersion(latestVersion);
+    int major = artifactVersion.getMajorVersion();
+    int minor = artifactVersion.getMinorVersion();
+    int patch = artifactVersion.getIncrementalVersion() + 1;
+    return major + "." + minor + "." + patch;
+  }
+}
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/BaseValidation.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/BaseValidation.java
new file mode 100644
index 0000000..890700d
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/BaseValidation.java
@@ -0,0 +1,128 @@
+package com.blazemeter.jmeter.correlation.gui.templates.validations;
+
+import com.blazemeter.jmeter.correlation.gui.common.PlaceHolderTextField;
+import com.blazemeter.jmeter.correlation.gui.templates.PlaceHolderComboBox;
+import java.awt.Color;
+import java.awt.Container;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.swing.BorderFactory;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.JTextField;
+import javax.swing.JViewport;
+import javax.swing.UIManager;
+import javax.swing.border.Border;
+import javax.swing.text.JTextComponent;
+
+public class BaseValidation<T extends JTextComponent> implements ComponentValidation<T> {
+  protected final Border fallbackBorder = new JTextField().getBorder();
+  protected final Border invalidBorder = BorderFactory.createLineBorder(Color.red);
+  protected Border defaultBorder;
+
+  protected T field;
+  protected JLabel error;
+  protected List<Condition> conditions = new ArrayList<>();
+
+  public BaseValidation(T field, JLabel error, List<Condition> conditionRules) {
+    this.field = field;
+    this.error = error;
+    this.conditions = conditionRules;
+    this.defaultBorder = getDefaultBorderForComponent(field);
+  }
+
+  @Override
+  public void applyFormat() {
+    boolean valid = isValid();
+    getOutermostComponent(field).setBorder(valid ? defaultBorder : invalidBorder);
+    error.setVisible(!valid);
+    error.setText(valid ? "" : conditions.stream()
+        .filter(validation -> !validation.isValid())
+        .map(Condition::getErrorMessage)
+        .collect(Collectors.joining(". ")));
+  }
+
+  private JComponent getOutermostComponent(T field) {
+    if (field instanceof JTextArea) {
+      Container parent = field.getParent();
+      if (parent instanceof JViewport) {
+        Container grandParent = parent.getParent();
+        if (grandParent instanceof JScrollPane) {
+          return (JScrollPane) grandParent;
+        }
+      }
+    }
+
+    if (field instanceof PlaceHolderTextField) {
+      Container parent = field.getParent();
+      if (parent instanceof PlaceHolderComboBox) {
+        return (PlaceHolderComboBox) parent;
+      }
+    }
+
+    return field;
+  }
+
+  private Border getDefaultBorderForComponent(JComponent component) {
+    if (component instanceof JTextField
+        && UIManager.getBorder("TextField.border") != null) {
+      return UIManager.getBorder("TextField.border");
+    } else if (component instanceof JTextArea
+        && UIManager.getBorder("TextArea.border") != null) {
+      return UIManager.getBorder("TextArea.border");
+    }
+
+    return fallbackBorder;
+  }
+
+  private String getValidString() {
+    return "It is " + (isValid() ? "valid" : "invalid");
+  }
+
+  @Override
+  public void updateValidationStates() {
+    System.out.println("Updating " + conditions.size() + " conditions for field "
+        + field.getName() + ". Currently " + getValidString());
+    for (Condition condition : conditions) {
+      condition.updateState(field.getText());
+    }
+    System.out.println("Updated state: " + getValidString());
+  }
+
+  @Override
+  public boolean isValid() {
+    for (Condition condition : conditions) {
+      if (!condition.isValid()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @Override
+  public T getField() {
+    return field;
+  }
+
+  @Override
+  public void setErrorMessage(String message) {
+    error.setText(message);
+  }
+
+  @Override
+  public String getErrorMessage() {
+    return error.getText();
+  }
+
+  @Override
+  public void reset() {
+    field.setText("");
+    field.setBorder(defaultBorder);
+    error.setText("");
+    error.setVisible(false);
+  }
+}
+
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/ComponentValidation.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/ComponentValidation.java
new file mode 100644
index 0000000..eee3864
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/ComponentValidation.java
@@ -0,0 +1,20 @@
+package com.blazemeter.jmeter.correlation.gui.templates.validations;
+
+import javax.swing.text.JTextComponent;
+
+public interface ComponentValidation<T extends JTextComponent> {
+  void updateValidationStates();
+
+  void applyFormat();
+
+  boolean isValid();
+
+  T getField();
+
+  void setErrorMessage(String message);
+
+  String getErrorMessage();
+
+  void reset();
+}
+
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/Condition.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/Condition.java
new file mode 100644
index 0000000..384c2c0
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/Condition.java
@@ -0,0 +1,10 @@
+package com.blazemeter.jmeter.correlation.gui.templates.validations;
+
+public interface Condition {
+  boolean isValid();
+
+  void updateState(String input);
+
+  String getErrorMessage();
+}
+
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/ValidationManager.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/ValidationManager.java
new file mode 100644
index 0000000..ccd607d
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/ValidationManager.java
@@ -0,0 +1,131 @@
+package com.blazemeter.jmeter.correlation.gui.templates.validations;
+
+import java.awt.Component;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JLabel;
+import javax.swing.text.JTextComponent;
+
+public class ValidationManager {
+
+  private final Set<Component> interactedFields = new HashSet<>();
+  private final Map<Component, ComponentValidation<?>> validations = new HashMap<>();
+  private JButton saveButton;
+  private Runnable afterValidation;
+
+  public <T extends JTextComponent> void register(T component, JLabel errorLabel,
+                                                  List<Condition> validationRules) {
+    ComponentValidation<T> validation =
+        new BaseValidation<>(component, errorLabel, validationRules);
+    validations.put(component, validation);
+
+    // If the field has a default value, assume the user has interacted with it.
+    if (!component.getText().isEmpty()) {
+      interactedFields.add(component);
+    }
+
+    component.addFocusListener(new FocusAdapter() {
+      @Override
+      public void focusLost(FocusEvent e) {
+        interactedFields.add(component);
+        validation.updateValidationStates();
+        validation.applyFormat();
+
+        updateSaveButtonState();
+        triggerAfterValidation();
+      }
+    });
+  }
+
+  public void register(JComboBox<?> comboBox, JLabel errorLabel, List<Condition> validationRules) {
+    JTextComponent editor = (JTextComponent) comboBox.getEditor().getEditorComponent();
+    ComponentValidation<JTextComponent> validation =
+        new BaseValidation<>(editor, errorLabel, validationRules);
+    validations.put(editor, validation);
+
+    // If the JComboBox has a default selection, assume the user has interacted with it.
+    if (comboBox.getSelectedItem() != null) {
+      interactedFields.add(editor);
+    }
+
+    editor.addFocusListener(new FocusAdapter() {
+      @Override
+      public void focusLost(FocusEvent e) {
+        interactedFields.add(editor);
+        validation.applyFormat();
+
+        updateSaveButtonState();
+        triggerAfterValidation();
+      }
+    });
+  }
+
+  private void triggerAfterValidation() {
+    if (afterValidation != null) {
+      afterValidation.run();
+    }
+  }
+
+  private void updateSaveButtonState() {
+    boolean valid = isValid();
+    boolean allValid = true;
+    for (ComponentValidation<?> compValidation : validations.values()) {
+      boolean componentInvalid = !compValidation.isValid();
+      JTextComponent field = compValidation.getField();
+      if (componentInvalid) {
+        allValid = false;
+        break;  // If any interacted field is invalid, we can stop checking.
+      }
+    }
+    saveButton.setEnabled(allValid);
+  }
+
+  public boolean isValid() {
+    for (ComponentValidation<?> validation : validations.values()) {
+      validation.updateValidationStates();
+      if (!validation.isValid()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  public boolean validateAll() {
+    for (ComponentValidation<?> validation : validations.values()) {
+      validation.applyFormat();
+    }
+
+    for (ComponentValidation<?> validation : validations.values()) {
+      if (!validation.isValid()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  public JButton getSaveButton() {
+    return saveButton;
+  }
+
+  public void setSaveButton(JButton saveButton) {
+    this.saveButton = saveButton;
+  }
+
+  public void setAfterValidation(Runnable afterValidation) {
+    this.afterValidation = afterValidation;
+  }
+
+  public void resetAll() {
+    validations.values().forEach(ComponentValidation::reset);
+    interactedFields.clear();
+    saveButton.setEnabled(false);
+  }
+}
+
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/type/NoNumbersCondition.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/type/NoNumbersCondition.java
new file mode 100644
index 0000000..788ab74
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/type/NoNumbersCondition.java
@@ -0,0 +1,24 @@
+package com.blazemeter.jmeter.correlation.gui.templates.validations.type;
+
+import com.blazemeter.jmeter.correlation.gui.templates.validations.Condition;
+
+public class NoNumbersCondition implements Condition {
+  private boolean valid;
+
+  @Override
+  public boolean isValid() {
+    return valid;
+  }
+
+  @Override
+  public void updateState(String input) {
+    valid = input != null && !input.matches(".*\\d+.*");
+  }
+
+  @Override
+  public String getErrorMessage() {
+    return "Field cannot contain numbers.";
+  }
+}
+
+
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/type/NotEmptyCondition.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/type/NotEmptyCondition.java
new file mode 100644
index 0000000..5a98878
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/type/NotEmptyCondition.java
@@ -0,0 +1,23 @@
+package com.blazemeter.jmeter.correlation.gui.templates.validations.type;
+
+import com.blazemeter.jmeter.correlation.gui.templates.validations.Condition;
+
+public class NotEmptyCondition implements Condition {
+  private boolean valid;
+
+  @Override
+  public boolean isValid() {
+    return valid;
+  }
+
+  @Override
+  public void updateState(String input) {
+    valid = input != null && !input.trim().isEmpty();
+  }
+
+  @Override
+  public String getErrorMessage() {
+    return "Field cannot be empty.";
+  }
+}
+
diff --git a/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/type/UniqueVersionCondition.java b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/type/UniqueVersionCondition.java
new file mode 100644
index 0000000..e272096
--- /dev/null
+++ b/src/main/java/com/blazemeter/jmeter/correlation/gui/templates/validations/type/UniqueVersionCondition.java
@@ -0,0 +1,35 @@
+package com.blazemeter.jmeter.correlation.gui.templates.validations.type;
+
+import com.blazemeter.jmeter.correlation.gui.templates.validations.Condition;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class UniqueVersionCondition implements Condition {
+  private boolean valid;
+  private Supplier<List<String>> getVersions;
+
+  @Override
+  public boolean isValid() {
+    return valid;
+  }
+
+  @Override
+  public void updateState(String input) {
+    if (getVersions == null) {
+      valid = false;
+      return;
+    }
+
+    List<String> versions = getVersions.get();
+    valid = versions.stream().noneMatch(version -> version.equals(input));
+  }
+
+  @Override
+  public String getErrorMessage() {
+    return "Version already exists.";
+  }
+
+  public void setVersionsSupplier(Supplier<List<String>> getVersions) {
+    this.getVersions = getVersions;
+  }
+}
diff --git a/src/main/resources/correlation-descriptions/TemplateSaveFrame.html b/src/main/resources/correlation-descriptions/TemplateSaveFrame.html
new file mode 100644
index 0000000..be33f6a
--- /dev/null
+++ b/src/main/resources/correlation-descriptions/TemplateSaveFrame.html
@@ -0,0 +1,56 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Help Guide: Saving Your Correlation Template</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            font-size: 14px;
+            color: #333;
+            margin: 15px;
+        }
+        h1 {
+            font-size: 18px;
+            margin-bottom: 10px;
+        }
+        h2 {
+            font-size: 16px;
+            margin-top: 15px;
+            margin-bottom: 10px;
+        }
+        p {
+            margin-bottom: 10px;
+        }
+    </style>
+</head>
+<body>
+<h1>Help Guide: Saving Your Correlation Template</h1>
+<p>This guide assists you in navigating the form to save your template. The form consists of two main tabs:</p>
+<ol>
+    <li><strong>Version's Information:</strong> Details specific to the current version.</li>
+    <li><strong>Template's Information:</strong> General details about the template itself.</li>
+</ol>
+
+<h2>1. Version's Information Tab:</h2>
+<ul>
+    <li><strong>Repository:</strong> Choose a repository from the combo box. This determines where your template will be saved. Default is "local" for your local storage. If you've set up BlazeMeter, relevant workspaces will appear here. Only writable repositories are displayed.</li>
+    <li><strong>Template:</strong> Lists available templates in the selected repository. Choosing a template will update the Versions combo. If a needed template isn't listed, manually inputting it will create a new one.</li>
+    <li><strong>Versions:</strong> Shows template versions available locally. Picking a version auto-suggests a new version number in the "New Version" field, but there's no strict link between them. It's just a guide.</li>
+    <li><strong>New Version:</strong> Suggests a version based on the selected one. It's recommended to use Semantic versioning for template versions.</li>
+    <li><strong>Changes:</strong> Document the differences between this and the previous version. Maintaining a change log is advisable.</li>
+</ul>
+
+<h2>2. Template's Information Tab:</h2>
+<ul>
+    <li><strong>Template Description:</strong> A space to describe the template's purpose and functionality. HTML tags are permitted.</li>
+    <li><strong>Author's Name & Link:</strong> Self-explanatory.</li>
+    <li><strong>Dependencies:</strong> Add relevant dependency links for your template.</li>
+</ul>
+
+<p><strong>Saving Your Template:</strong><br>
+    Click on the 'Save' button. If it's grayed out, a required field needs correcting. Fields with errors will have a red note underneath pinpointing the issue.</p>
+
+</body>
+</html>
diff --git a/src/test/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlBuilder.java b/src/test/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlBuilder.java
index 9887931..ad1e8d8 100644
--- a/src/test/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlBuilder.java
+++ b/src/test/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlBuilder.java
@@ -63,8 +63,9 @@ public CorrelationProxyControl build() {
     repositoriesRegistry = repositoriesRegistry != null ?
         repositoriesRegistry
         : new CorrelationTemplatesRepositoriesConfiguration(configuration);
-    CorrelationProxyControl model = new CorrelationProxyControl(registry, repositoriesRegistry,
-        configuration, engine, templatesRegistry);
+
+    CorrelationProxyControl model =
+        new CorrelationProxyControl(registry, repositoriesRegistry, configuration, engine);
     model.setName("bzm - Correlation Recorder");
 
     if (target != null) {
diff --git a/src/test/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlTest.java b/src/test/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlTest.java
index de128b6..c8b701e 100644
--- a/src/test/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlTest.java
+++ b/src/test/java/com/blazemeter/jmeter/correlation/CorrelationProxyControlTest.java
@@ -6,6 +6,7 @@
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
+
 import com.blazemeter.jmeter.correlation.core.CorrelationEngine;
 import com.blazemeter.jmeter.correlation.core.CorrelationRule;
 import com.blazemeter.jmeter.correlation.core.RulesGroup;
@@ -150,7 +151,7 @@ public void shouldBuildCorrelationRulesWhenOnSaveTemplateWithRulesWithoutCorrela
     model.onSaveTemplate(BASE_TEMPLATE_BUILDER);
 
     //Its been called once since only save the CorrelationTemplate once after building it
-    verify(correlationComponentsRegistry, only()).save(prepareExpectedTemplate(groups));
+    verify(localConfiguration, only()).saveTemplate(prepareExpectedTemplate(groups));
   }
 
   private List<CorrelationRule> prepareRulesWithoutCorrelationExtractors() {
@@ -173,8 +174,8 @@ public void shouldBuildCorrelationRulesWhenOnSaveTemplateWithRulesWithoutCorrela
     model.setCorrelationGroups(groups);
     model.onSaveTemplate(BASE_TEMPLATE_BUILDER);
 
-    //Its been called once since only save the CorrelationTemplate once after building it
-    verify(correlationComponentsRegistry, only()).save(prepareExpectedTemplate(groups));
+    //It's been called once since only save the CorrelationTemplate once after building it
+    verify(localConfiguration, only()).saveTemplate(prepareExpectedTemplate(groups));
   }
 
   private List<RulesGroup> prepareGroupOfRulesWithoutCorrelationReplacements() {
@@ -189,7 +190,7 @@ private List<RulesGroup> prepareGroupOfRulesWithoutCorrelationReplacements() {
 
   @Test
   public void shouldAppendLoadedTemplateWhenOnLoadTemplate() throws IOException {
-    when(correlationComponentsRegistry.findByID(LOCAL_REPOSITORY_ID, TEMPLATE_ID, TEMPLATE_VERSION))
+    when(localConfiguration.findById(LOCAL_REPOSITORY_ID, TEMPLATE_ID, TEMPLATE_VERSION))
         .thenReturn(Optional.of(testTemplate));
 
     when(testTemplate.getResponseFilters())
@@ -243,7 +244,7 @@ private String buildArrayFromListOfStrings(String... strings) {
 
   @Test
   public void shouldRemoveRepeatedElementsWhenWhenOnLoadTemplate() throws IOException {
-    when(correlationComponentsRegistry.findByID(LOCAL_REPOSITORY_ID, TEMPLATE_ID, TEMPLATE_VERSION))
+    when(localConfiguration.findById(LOCAL_REPOSITORY_ID, TEMPLATE_ID, TEMPLATE_VERSION))
         .thenReturn(Optional.of(testTemplate));
 
     when(testTemplate.getResponseFilters()).thenReturn(
diff --git a/src/test/java/com/blazemeter/jmeter/correlation/core/automatic/CorrelationWizardIT.java b/src/test/java/com/blazemeter/jmeter/correlation/core/automatic/CorrelationWizardIT.java
index 7aa4235..79519a9 100644
--- a/src/test/java/com/blazemeter/jmeter/correlation/core/automatic/CorrelationWizardIT.java
+++ b/src/test/java/com/blazemeter/jmeter/correlation/core/automatic/CorrelationWizardIT.java
@@ -4,9 +4,7 @@
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplateVersions;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepositoriesConfiguration;
 import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepository;
-import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRepositoryConfiguration;
 import com.blazemeter.jmeter.correlation.core.templates.LocalConfiguration;
-import com.blazemeter.jmeter.correlation.core.templates.LocalCorrelationTemplatesRepositoriesRegistry;
 import com.blazemeter.jmeter.correlation.core.templates.repository.RepositoryManager;
 import com.blazemeter.jmeter.correlation.gui.automatic.CorrelationWizard;
 import java.awt.Dimension;
@@ -68,12 +66,6 @@ public static void main(String[] args) {
     String path = "/Users/abstracta/testing/jmeter-siebel-plugin/jmeters/apache-jmeter-5.5/";
     LocalConfiguration configuration = new LocalConfiguration(path, true);
     configuration.setupRepositoryManagers();
-
-    LocalCorrelationTemplatesRepositoriesRegistry local =
-        new LocalCorrelationTemplatesRepositoriesRegistry(configuration);
-    List<CorrelationTemplatesRepository> repositories1 = local.getRepositories();
-
-
     /*
     *
     *     LocalConfiguration localConfiguration = new LocalConfiguration(folder.getRoot().getPath(), true);
@@ -86,14 +78,11 @@ public static void main(String[] args) {
     prepareExpectedLocalRepository();
     * */
 
-    List<CorrelationTemplatesRepositoryConfiguration> repositories =
-        configuration.getRepositories();
-
-
-    for (CorrelationTemplatesRepositoryConfiguration repository : repositories) {
+    List<CorrelationTemplatesRepository> repositories = configuration.getRepositories();
+    for (CorrelationTemplatesRepository repository : repositories) {
+      System.out.println(repository.getName());
       RepositoryManager manager = configuration.getRepositoryManager(repository.getName());
-      Map<String, CorrelationTemplateVersions> templateVersions = manager.getTemplateVersions();
-      System.out.println(templateVersions);
+      Map<String, CorrelationTemplateVersions> versions = manager.getTemplateVersions();
     }
 
     history = new CorrelationHistory();
diff --git a/src/test/java/com/blazemeter/jmeter/correlation/core/templates/LocalConfigurationTest.java b/src/test/java/com/blazemeter/jmeter/correlation/core/templates/LocalConfigurationTest.java
index 742bb6e..39046d0 100644
--- a/src/test/java/com/blazemeter/jmeter/correlation/core/templates/LocalConfigurationTest.java
+++ b/src/test/java/com/blazemeter/jmeter/correlation/core/templates/LocalConfigurationTest.java
@@ -39,7 +39,6 @@
 @RunWith(MockitoJUnitRunner.class)
 public class LocalConfigurationTest {
 
-  private static final String LOCAL_REPOSITORY_NAME = "local";
   private static final String VERSION_ONE = "1.0";
   private static final String DUMMY_FILE_VERSION_ONE = "dummy-1.0.jar";
   private static final String SIEBEL_REPO_NAME = "siebel";
@@ -68,12 +67,44 @@ public class LocalConfigurationTest {
   private CorrelationTemplatesRepositoryConfiguration repositoryWithInstalledTemplates;
   @Mock
   private CorrelationTemplatesRepositoryConfiguration localRepositoryConfiguration;
+  @Mock
+  private CorrelationTemplatesRepository expectedSiebelRepository;
+  @Mock
+  private CorrelationTemplatesRepository expectedCentralRepository;
   private final WireMockServer wireMockServer = new WireMockServer(wireMockConfig().dynamicPort());
   private LocalConfiguration configuration;
   private String dependenciesFolder;
+  private static final String TEMPLATE_FILE_SUFFIX = "template.json";
+
+  private static final String REPOSITORY_FILE_SUFFIX = "repository.json";
+
+  private static final String LOCAL_REPOSITORY_NAME = "local";
+  private static final String LOCAL_REPOSITORY_DISPLAY_NAME = "Local";
+
+  private static final String CENTRAL_REPOSITORY_NAME = "central";
+  private static final String CENTRAL_REPOSITORY_DISPLAY_NAME = "GitHub's Central";
+
+  private static final String SIEBEL_TEMPLATE_REFERENCE_NAME = "siebel";
+  private static final String WORDPRESS_TEMPLATE_REFERENCE_NAME = "wordpress";
+  private static final String TEMPLATE_VERSION_TWO = "1.1";
+  private static final String TEMPLATE_VERSION_ONE = "1.0";
+
+  private static final String TEMPLATE_VERSION_THREE = "0.1-alpha";
+
+  private static final String CORRELATION_TEMPLATES_REPOSITORY_NAME =
+      "CorrelationTemplatesRepository";
+
+  private static final String SIEBEL_TEMPLATE_VERSION_TWO_NAME =
+      SIEBEL_TEMPLATE_REFERENCE_NAME + "-" + TEMPLATE_VERSION_TWO + "-" + TEMPLATE_FILE_SUFFIX;
+  private static final String SIEBEL_TEMPLATE_VERSION_ONE_NAME =
+      SIEBEL_TEMPLATE_REFERENCE_NAME + "-" + TEMPLATE_VERSION_ONE + "-" + TEMPLATE_FILE_SUFFIX;
+
+  private static final String WORDPRESS_TEMPLATE_VERSION_ONE_NAME =
+      WORDPRESS_TEMPLATE_REFERENCE_NAME + "-" + TEMPLATE_VERSION_ONE + "-" + TEMPLATE_FILE_SUFFIX;
 
   @Before
   public void setUp() {
+    LocalConfiguration.installDefaultFiles(folder.getRoot().getPath());
     configuration = new LocalConfiguration(folder.getRoot().getPath(), true);
     configuration.setupRepositoryManagers();
     when(firstRepository.getName()).thenReturn(FIRST_REPO_NAME);
@@ -81,6 +112,7 @@ public void setUp() {
     when(localRepository.getName()).thenReturn(LOCAL_REPOSITORY_NAME);
     configuration.addRepository(firstRepository.getName(), firstRepositoryURL);
     dependenciesFolder = folder.getRoot().getAbsolutePath() + "/lib/";
+    prepareExpectedLocalRepository();
   }
 
   @After
@@ -89,6 +121,20 @@ public void tearDown() {
       wireMockServer.stop();
     }
   }
+  private void prepareExpectedLocalRepository() {
+    when(expectedSiebelRepository.getValues()).thenReturn(
+        CORRELATION_TEMPLATES_REPOSITORY_NAME + "{name='" + LOCAL_REPOSITORY_NAME
+            + "', displayName='" + LOCAL_REPOSITORY_DISPLAY_NAME
+            + "', templatesVersions={" + SIEBEL_TEMPLATE_REFERENCE_NAME +
+            "=CorrelationTemplateVersions {versions=[" + TEMPLATE_VERSION_ONE + "]}}}");
+
+    when(expectedCentralRepository.getValues()).thenReturn(
+        CORRELATION_TEMPLATES_REPOSITORY_NAME + "{name='" + CENTRAL_REPOSITORY_NAME
+            + "', displayName='" + CENTRAL_REPOSITORY_DISPLAY_NAME
+            + "', templatesVersions={" + WORDPRESS_TEMPLATE_REFERENCE_NAME +
+            "=CorrelationTemplateVersions {versions=[" + TEMPLATE_VERSION_THREE + "]}}}");
+
+  }
 
   public void configureWireMockServer() {
     wireMockServer.start();
@@ -374,4 +420,24 @@ public void shouldReturnErrorWhenCheckRepositoryURlWithNoJsonFile() {
             ".\n"
             + "   Error: URL should lead to .json file"), errors);
   }
+
+  @Test
+  public void shouldReturnLocalCorrelationTemplatesRepositoriesWhenGetRepositories() {
+    assertEquals(getRepositoriesNames(prepareExpectedLocalRepositories()),
+        getRepositoriesNames(configuration.getRepositories()));
+  }
+
+  private List<String> getRepositoriesNames(List<CorrelationTemplatesRepository> repositories) {
+    return repositories.stream().map(CorrelationTemplatesRepository::getValues)
+        .collect(Collectors.toList());
+  }
+
+  private List<CorrelationTemplatesRepository> prepareExpectedLocalRepositories() {
+    List<CorrelationTemplatesRepository> expectedLocalRepositories = new ArrayList<>();
+    expectedLocalRepositories.add(expectedCentralRepository);
+    expectedLocalRepositories.add(expectedSiebelRepository);
+
+    return expectedLocalRepositories;
+  }
+
 }
diff --git a/src/test/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRepositoriesRegistryTest.java b/src/test/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRepositoriesRegistryTest.java
index 8f96151..1f61f94 100644
--- a/src/test/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRepositoriesRegistryTest.java
+++ b/src/test/java/com/blazemeter/jmeter/correlation/core/templates/LocalCorrelationTemplatesRepositoriesRegistryTest.java
@@ -3,6 +3,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.when;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Paths;
@@ -27,8 +28,6 @@ public class LocalCorrelationTemplatesRepositoriesRegistryTest {
   private static final String TEMPLATE_FILE_SUFFIX = "template.json";
   private static final String REPOSITORY_FILE_SUFFIX = "repository.json";
   private static final String EXTERNAL_REPOSITORY_NAME = "base";
-  private static final String LOCAL_REPOSITORY_NAME = "local";
-  private static final String CENTRAL_REPOSITORY_NAME = "central";
   private static final String SIEBEL_TEMPLATE_REFERENCE_NAME = "siebel";
   private static final String WORDPRESS_TEMPLATE_REFERENCE_NAME = "wordpress";
 
@@ -38,8 +37,6 @@ public class LocalCorrelationTemplatesRepositoriesRegistryTest {
   private static final String TEMPLATE_VERSION_TWO = "1.1";
   private static final String TEMPLATE_VERSION_ONE = "1.0";
 
-  private static final String TEMPLATE_VERSION_THREE = "0.1-alpha";
-
   private static final String SIEBEL_TEMPLATE_VERSION_TWO_NAME =
       SIEBEL_TEMPLATE_REFERENCE_NAME + "-" + TEMPLATE_VERSION_TWO + "-" + TEMPLATE_FILE_SUFFIX;
   private static final String SIEBEL_TEMPLATE_VERSION_ONE_NAME =
@@ -54,14 +51,11 @@ public class LocalCorrelationTemplatesRepositoriesRegistryTest {
   public TemporaryFolder folder = new TemporaryFolder();
   @Mock
   private CorrelationTemplatesRepository expectedBaseRepository;
-  @Mock
-  private CorrelationTemplatesRepository expectedSiebelRepository;
-  @Mock
-  private CorrelationTemplatesRepository expectedCentralRepository;
   private LocalCorrelationTemplatesRepositoriesRegistry local;
 
   @Before
   public void setup() throws IOException {
+    LocalConfiguration.installDefaultFiles(folder.getRoot().getPath());
     LocalConfiguration localConfiguration =
         new LocalConfiguration(folder.getRoot().getPath(), true);
     localConfiguration.setupRepositoryManagers();
@@ -74,25 +68,15 @@ public void setup() throws IOException {
   }
 
   private void prepareExpectedLocalRepository() {
-    when(expectedSiebelRepository.getValues()).thenReturn(
-        CORRELATION_TEMPLATES_REPOSITORY_NAME + "{name='" + LOCAL_REPOSITORY_NAME
-            + "', templatesVersions={" + SIEBEL_TEMPLATE_REFERENCE_NAME +
-            "=CorrelationTemplateReference{versions=[" + TEMPLATE_VERSION_ONE + "]}}}");
-
-    when(expectedCentralRepository.getValues()).thenReturn(
-        CORRELATION_TEMPLATES_REPOSITORY_NAME + "{name='" + CENTRAL_REPOSITORY_NAME
-            + "', templatesVersions={" + WORDPRESS_TEMPLATE_REFERENCE_NAME +
-            "=CorrelationTemplateReference{versions=[" + TEMPLATE_VERSION_THREE + "]}}}");
-
     when(expectedBaseRepository.getName()).thenReturn(EXTERNAL_REPOSITORY_NAME);
     when(expectedBaseRepository.getValues()).thenReturn(
         CORRELATION_TEMPLATES_REPOSITORY_NAME + "{name='" + EXTERNAL_REPOSITORY_NAME
-            + "', templatesVersions={"
+            + "', displayName='null', templatesVersions={"
             + SIEBEL_TEMPLATE_REFERENCE_NAME
-            + "=CorrelationTemplateReference{versions=[" + TEMPLATE_VERSION_ONE
+            + "=CorrelationTemplateVersions {versions=[" + TEMPLATE_VERSION_ONE
             + ", " + TEMPLATE_VERSION_TWO + "]}, "
             + WORDPRESS_TEMPLATE_REFERENCE_NAME
-            + "=CorrelationTemplateReference{versions=[" + TEMPLATE_VERSION_ONE
+            + "=CorrelationTemplateVersions {versions=[" + TEMPLATE_VERSION_ONE
             + "]}}}");
   }
 
@@ -124,25 +108,6 @@ private List<String> getGeneratedFilesNames(String repositoryName) {
         .collect(Collectors.toList());
   }
 
-  @Test
-  public void shouldReturnLocalCorrelationTemplatesRepositoriesWhenGetRepositories() {
-    assertEquals(getRepositoriesNames(prepareExpectedLocalRepositories()),
-        getRepositoriesNames(local.getRepositories()));
-  }
-
-  private List<String> getRepositoriesNames(List<CorrelationTemplatesRepository> repositories) {
-    return repositories.stream().map(CorrelationTemplatesRepository::getValues)
-        .collect(Collectors.toList());
-  }
-
-  private List<CorrelationTemplatesRepository> prepareExpectedLocalRepositories() {
-    List<CorrelationTemplatesRepository> expectedLocalRepositories = new ArrayList<>();
-    expectedLocalRepositories.add(expectedCentralRepository);
-    expectedLocalRepositories.add(expectedSiebelRepository);
-    expectedLocalRepositories.add(expectedBaseRepository);
-
-    return expectedLocalRepositories;
-  }
 
   @Test
   public void shouldFindRepositoryByIdWhenFind() {
diff --git a/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateDependenciasTableIT.java b/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateDependenciasTableIT.java
new file mode 100644
index 0000000..c7d6927
--- /dev/null
+++ b/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateDependenciasTableIT.java
@@ -0,0 +1,104 @@
+package com.blazemeter.jmeter.correlation.gui.templates;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.when;
+import com.blazemeter.jmeter.correlation.SwingTestRunner;
+import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplateDependency;
+import com.blazemeter.jmeter.correlation.core.templates.CorrelationTemplatesRegistryHandler;
+import com.blazemeter.jmeter.correlation.core.templates.Template;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import org.assertj.swing.fixture.FrameFixture;
+import org.assertj.swing.fixture.JButtonFixture;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+
+@RunWith(SwingTestRunner.class)
+public class TemplateDependenciasTableIT {
+
+  private static final String TEMPLATE_DESCRIPTION = "TestDescription";
+  private static final String TEMPLATE_VERSION = "1.0.0";
+  private static final String TEMPLATE_ID = "TestID";
+  private FrameFixture frame;
+  private TemplateDependenciesTable templateSaveFrame;
+  private Set<Template> lastLoadedTemplates;
+  @Mock
+  private CorrelationTemplatesRegistryHandler templatesRegistry;
+  @Mock
+  private CorrelationTemplateDependency firstDependency;
+  @Mock
+  private CorrelationTemplateDependency secondDependency;
+  @Mock
+  private CorrelationTemplateDependency thirdDependency;
+  @Mock
+  private Template registeredTemplate;
+  @Mock
+  private Template lastLoadedTemplate;
+
+  @Test
+  public void shouldAddDependencyWhenAddPressed() {
+    openAdvancedSectionPanel();
+    findDependencyAddButton().click();
+    assertThat(templateSaveFrame.getDependencies()).isNotEmpty();
+  }
+
+  private void openAdvancedSectionPanel() {
+    frame.button("-collapsiblePanel-header-collapseButton").click();
+  }
+
+  private JButtonFixture findDependencyAddButton() {
+    return frame.button("addButton");
+  }
+
+  @Test
+  public void shouldClearRulesWhenClearPressed() {
+    openAdvancedSectionPanel();
+    findDependencyAddButton().click();
+    frame.button("clearButton").click();
+    assertThat(templateSaveFrame.getDependencies()).isEmpty();
+  }
+
+  @Test
+  public void shouldSetDependenciesWhenSetDependencies() {
+    List<CorrelationTemplateDependency> dependencies = buildExpectedDependencies();
+    templateSaveFrame.setDependencies(dependencies);
+    assertThat(templateSaveFrame.getDependencies().size()).isEqualTo(
+        dependencies.size());
+  }
+
+  private List<CorrelationTemplateDependency> buildExpectedDependencies() {
+    return Arrays.asList(firstDependency, secondDependency);
+  }
+
+
+
+  private void prepareRegisteredTemplate() {
+    when(registeredTemplate.getId()).thenReturn(TEMPLATE_ID);
+    when(registeredTemplate.getVersion()).thenReturn(TEMPLATE_VERSION);
+    when(registeredTemplate.getDescription()).thenReturn(TEMPLATE_DESCRIPTION);
+    when(registeredTemplate.getDependencies())
+        .thenReturn(Arrays.asList(firstDependency, secondDependency));
+  }
+
+  private void prepareDependencies() {
+    prepareDependencyAndUrlValidity(firstDependency, 1, true);
+    prepareDependencyAndUrlValidity(secondDependency, 1, true);
+  }
+
+  private void prepareDependencyAndUrlValidity(CorrelationTemplateDependency dependency,
+                                               int number,
+                                               boolean urlValidity) {
+    String dependencyName = "Dependency" + number;
+    String dependencyVersion = number + ".0";
+    String dependencyURL = "ulr" + number;
+
+    when(dependency.getName()).thenReturn(dependencyName);
+    when(dependency.getVersion()).thenReturn(dependencyVersion);
+    when(dependency.getUrl()).thenReturn(dependencyURL);
+    when(templatesRegistry
+        .isValidDependencyURL(dependencyURL, dependencyName, dependencyVersion))
+        .thenReturn(urlValidity);
+  }
+}
diff --git a/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateManagerDisplaySaveFrameIT.java b/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateManagerDisplaySaveFrameIT.java
index d1a7757..2162063 100644
--- a/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateManagerDisplaySaveFrameIT.java
+++ b/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/TemplateManagerDisplaySaveFrameIT.java
@@ -12,13 +12,12 @@
 import com.blazemeter.jmeter.correlation.core.templates.Template;
 import com.blazemeter.jmeter.correlation.core.templates.Template.Builder;
 import java.awt.Container;
+import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.function.Consumer;
 import javax.swing.JPanel;
 import org.assertj.swing.fixture.FrameFixture;
@@ -56,14 +55,16 @@ public class TemplateManagerDisplaySaveFrameIT {
   private CorrelationTemplateDependency thirdDependency;
   @Mock
   private Consumer<Template> lastTemplateHandler;
+  @Mock
+  private BufferedImage snapshot;
   private TemplateSaveFrame templateSaveFrame;
-  private Set<Template> lastLoadedTemplates;
+  private List<Template> lastLoadedTemplates;
 
   @Before
   public void setup() {
     templateSaveFrame = new TemplateSaveFrame(templatesRegistry, null,
-        lastTemplateHandler, new JPanel());
-    lastLoadedTemplates = new HashSet<>(Collections.singletonList(registeredTemplate));
+        snapshot, lastTemplateHandler, new JPanel());
+    lastLoadedTemplates = Collections.singletonList(registeredTemplate);
     Container contentPane = templateSaveFrame.getContentPane();
     frame = showInFrame(contentPane);
   }
@@ -145,10 +146,14 @@ private void requireMessage(String message) {
   @Test
   public void shouldShowTemplateIDWhenSetLoadedTemplatesWithOneLoadedTemplate() {
     prepareRegisteredTemplate();
-    templateSaveFrame.setLoadedTemplates(lastLoadedTemplates);
+    templateSaveFrame.setLoadedTemplates(getLastLoadedTemplate());
     assertThat(findTemplateIdField().text()).isEqualTo(TEMPLATE_ID);
   }
 
+  private Template getLastLoadedTemplate() {
+    return lastLoadedTemplates.get(lastLoadedTemplates.size() - 1);
+  }
+
   private void prepareRegisteredTemplate() {
     when(registeredTemplate.getId()).thenReturn(TEMPLATE_ID);
     when(registeredTemplate.getVersion()).thenReturn(TEMPLATE_VERSION);
@@ -161,14 +166,14 @@ private void prepareRegisteredTemplate() {
   @Test
   public void shouldSetupVersionFieldWhenSetLoadTemplatesWithOneLoadedTemplate() {
     prepareRegisteredTemplate();
-    templateSaveFrame.setLoadedTemplates(lastLoadedTemplates);
+    templateSaveFrame.setLoadedTemplates(getLastLoadedTemplate());
     assertThat(findTemplateVersionField().text()).isEqualTo(TEMPLATE_VERSION);
   }
 
   @Test
   public void shouldSetupDescriptionFieldWhenSetLoadTemplatesWithOneLoadedTemplate() {
     prepareRegisteredTemplate();
-    templateSaveFrame.setLoadedTemplates(lastLoadedTemplates);
+    templateSaveFrame.setLoadedTemplates(getLastLoadedTemplate());
     assertThat(findTemplateDescriptionField().text()).isEqualTo(TEMPLATE_DESCRIPTION);
   }
 
@@ -176,7 +181,7 @@ public void shouldSetupDescriptionFieldWhenSetLoadTemplatesWithOneLoadedTemplate
   public void shouldShowTemplateIDEmptyWhenSetLoadedTemplatesWithMultipleLoadedTemplate() {
     prepareRegisteredTemplate();
     lastLoadedTemplates.add(lastLoadedTemplate);
-    templateSaveFrame.setLoadedTemplates(lastLoadedTemplates);
+    templateSaveFrame.setLoadedTemplates(getLastLoadedTemplate());
     assertThat(findTemplateIdField().text()).isEmpty();
   }
 
@@ -184,7 +189,7 @@ public void shouldShowTemplateIDEmptyWhenSetLoadedTemplatesWithMultipleLoadedTem
   public void shouldShowTemplateDescriptionEmptyWhenSetLoadedTemplatesWithMultipleLoadedTemplate() {
     prepareRegisteredTemplate();
     lastLoadedTemplates.add(lastLoadedTemplate);
-    templateSaveFrame.setLoadedTemplates(lastLoadedTemplates);
+    templateSaveFrame.setLoadedTemplates(getLastLoadedTemplate());
     assertThat(findTemplateDescriptionField().text()).isEmpty();
   }
 
@@ -209,29 +214,6 @@ private JButtonFixture findDependencyAddButton() {
     return frame.button("addButton");
   }
 
-  @Test
-  public void shouldAddDependencyWhenAddPressed() {
-    openAdvancedSectionPanel();
-    findDependencyAddButton().click();
-    assertThat(templateSaveFrame.getDependencies()).isNotEmpty();
-  }
-
-  @Test
-  public void shouldClearRulesWhenClearPressed() {
-    openAdvancedSectionPanel();
-    findDependencyAddButton().click();
-    frame.button("clearButton").click();
-    assertThat(templateSaveFrame.getDependencies()).isEmpty();
-  }
-
-  @Test
-  public void shouldSetDependenciesWhenSetDependencies() {
-    List<CorrelationTemplateDependency> dependencies = buildExpectedDependencies();
-    templateSaveFrame.setDependencies(dependencies);
-    assertThat(templateSaveFrame.getDependencies().size()).isEqualTo(
-        dependencies.size());
-  }
-
   private List<CorrelationTemplateDependency> buildExpectedDependencies() {
     return Arrays.asList(firstDependency, secondDependency);
   }
@@ -287,17 +269,6 @@ public void shouldDisplayWarningMessageWhenSaveWithInvalidUrlDependency() {
             + "Check the logs for more information.");
   }
 
-  @Test
-  public void shouldLoadMultipleDependenciesWhenLoadWithMultipleLoadedTemplates() {
-    prepareDependencies();
-    prepareRegisteredTemplate();
-    when(lastLoadedTemplate.getDependencies())
-        .thenReturn(Collections.singletonList(thirdDependency));
-    lastLoadedTemplates.add(lastLoadedTemplate);
-    templateSaveFrame.setLoadedTemplates(lastLoadedTemplates);
-    assertThat(templateSaveFrame.getDependencies().size()).isEqualTo(3);
-  }
-
   @Test
   public void shouldDisableSaveButtonWhenFormHasErrors() {
     findTemplateIdField().setText(TEMPLATE_ID + " /");
@@ -393,4 +364,15 @@ public void shouldEnableSaveButtonWhenFillFieldWithValidTexts() {
     findSaveButton().focus();
     assertThat(findSaveButton().isEnabled()).isTrue();
   }
+
+  @Test
+  public void shouldLoadMultipleDependenciesWhenLoadWithMultipleLoadedTemplates() {
+    prepareDependencies();
+    prepareRegisteredTemplate();
+    when(lastLoadedTemplate.getDependencies())
+        .thenReturn(Collections.singletonList(thirdDependency));
+    lastLoadedTemplates.add(lastLoadedTemplate);
+    templateSaveFrame.setLoadedTemplates(getLastLoadedTemplate());
+    assertThat(templateSaveFrame.getDependenciesTable().getDependencies().size()).isEqualTo(3);
+  }
 }
diff --git a/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/ValidationTest.java b/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/ValidationTest.java
deleted file mode 100644
index 069a891..0000000
--- a/src/test/java/com/blazemeter/jmeter/correlation/gui/templates/ValidationTest.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package com.blazemeter.jmeter.correlation.gui.templates;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import org.junit.Test;
-
-public class ValidationTest {
-
-  private Validation validation;
-
-  @Test
-  public void shouldReturnFalseWhenFailsValidationIsMeet() {
-    validation = new Validation(text -> text.isEmpty(), "%s is empty");
-    assertThat(validation.failsValidation("")).isTrue();
-  }
-
-  @Test
-  public void shouldReturnFalseWhenFailsValidationNotMeet() {
-    validation = new Validation(text -> text.isEmpty(), "%s is empty");
-    validation.failsValidation("Not empty text");
-    assertThat(validation.failsValidation("Not empty text")).isFalse();
-  }
-
-  @Test
-  public void shouldFormatErrorMessageWhenFailsValidationIsMeet() {
-    validation = new Validation(text -> text.isEmpty(), "%s is empty");
-    validation.failsValidation("");
-    assertThat(validation.formatErrorMessage("ID")).isEqualTo("ID is empty");
-  }
-}