diff --git a/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabProjectViewModel.cs b/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabProjectViewModel.cs
index ebcff3d4..68d56e22 100644
--- a/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabProjectViewModel.cs
+++ b/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabProjectViewModel.cs
@@ -52,9 +52,9 @@ public string GroupName
             }
         }
 
-        public IEnumerable<PrefabVersion> DeployedVersions 
-        { 
-            get => this.prefabProject.AvailableVersions.Where(a => a.IsDeployed).ToList(); 
+        public IEnumerable<PrefabVersion> PublishedVersion 
+        {
+            get => this.prefabProject.PublishedVersions; 
         }
 
         public PrefabProjectViewModel(PrefabProject prefabProject)
diff --git a/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionManagerViewModel.cs b/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionManagerViewModel.cs
index 66698d1a..b312eb82 100644
--- a/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionManagerViewModel.cs
+++ b/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionManagerViewModel.cs
@@ -22,7 +22,7 @@ public class PrefabVersionManagerViewModel : Screen , IVersionManager
         private readonly PrefabProject prefabProject;
         private readonly ApplicationSettings applicationSettings;
 
-        private bool wasDeployed = false;
+        private bool wasPublished = false;
 
         public BindableCollection<PrefabVersionViewModel> AvailableVersions { get; set; } = new BindableCollection<PrefabVersionViewModel>();
        
@@ -30,7 +30,7 @@ public class PrefabVersionManagerViewModel : Screen , IVersionManager
         public PrefabVersionManagerViewModel(PrefabProject prefabProject, IWorkspaceManagerFactory workspaceManagerFactory, IReferenceManagerFactory referenceManagerFactory,
             ISerializer serializer, IApplicationDataManager applicationDataManager,  ApplicationSettings applicationSettings)
         {
-            this.DisplayName = "Manage & Deploy Versions";
+            this.DisplayName = "Manage Prefab Versions";
             this.workspaceManagerFactory = Guard.Argument(workspaceManagerFactory, nameof(workspaceManagerFactory)).NotNull().Value;
             this.referenceManagerFactory = Guard.Argument(referenceManagerFactory, nameof(referenceManagerFactory)).NotNull().Value;
             this.serializer = Guard.Argument(serializer, nameof(serializer)).NotNull().Value;
@@ -45,36 +45,70 @@ public PrefabVersionManagerViewModel(PrefabProject prefabProject, IWorkspaceMana
         }
 
         /// <summary>
-        /// Create a copy of selected version and deploy the selected version.
+        /// Create a copy of selected version and mark the selected version as published.
         /// </summary>
         /// <returns></returns>
-        public async Task Deploy(PrefabVersionViewModel prefabVersionViewModel)
+        public async Task CloneAndPublishAsync(PrefabVersionViewModel prefabVersionViewModel)
         {
             try
             {
-                if (prefabVersionViewModel?.IsActive == true)
+                logger.Information($"Trying to clone version {prefabVersionViewModel.Version} for Prefab : {this.prefabProject.PrefabName}");
+
+                //Create a new active version from selected version
+                PrefabVersion newVersion = prefabVersionViewModel.Clone();
+                IPrefabFileSystem fileSystem = new PrefabFileSystem(serializer, applicationSettings);
+                fileSystem.Initialize(this.prefabProject, newVersion);
+
+                //Publish the selected version
+                if(!prefabVersionViewModel.IsPublished)
                 {
-                    //Create a new active version from selected version
-                    PrefabVersion newVersion = prefabVersionViewModel.Clone();
+                    prefabVersionViewModel.Publish(this.workspaceManagerFactory);
+                    logger.Information($"Version {prefabVersionViewModel.Version} for Prefab : {this.prefabProject.PrefabName} is published now.");
+                }
 
-                    IPrefabFileSystem fileSystem = new PrefabFileSystem(serializer, applicationSettings);
-                    fileSystem.Initialize(this.prefabProject, newVersion);                  
+                int indexToInsert = 0;
+                foreach (var version in this.prefabProject.AvailableVersions.Select(s => s.Version))
+                {                   
+                    if (version < newVersion.Version)
+                    {
+                        indexToInsert++;
+                        continue;
+                    }                          
+                    break;
+                }
 
-                    //Deploy the selected version
-                    prefabVersionViewModel.Deploy(this.workspaceManagerFactory);
+                this.prefabProject.AvailableVersions.Insert(indexToInsert, newVersion);
+                serializer.Serialize<PrefabProject>(fileSystem.PrefabDescriptionFile, this.prefabProject);
 
-                    this.prefabProject.AvailableVersions.Add(newVersion);
-                    serializer.Serialize<PrefabProject>(fileSystem.PrefabDescriptionFile, this.prefabProject);
+                await this.applicationDataManager.AddOrUpdatePrefabAsync(this.prefabProject, new PrefabVersion(prefabVersionViewModel.Version) { IsActive = false });
+                await this.applicationDataManager.AddOrUpdatePrefabDataFilesAsync(this.prefabProject, new PrefabVersion(prefabVersionViewModel.Version) { IsActive = false });
+                await this.applicationDataManager.AddOrUpdatePrefabDataFilesAsync(this.prefabProject, newVersion);
 
-                    await this.applicationDataManager.AddOrUpdatePrefabAsync(this.prefabProject, new PrefabVersion(prefabVersionViewModel.Version) { IsDeployed = true, IsActive = false });
-                    await this.applicationDataManager.AddOrUpdatePrefabDataFilesAsync(this.prefabProject, new PrefabVersion(prefabVersionViewModel.Version) { IsDeployed = true, IsActive = false });
-                    await this.applicationDataManager.AddOrUpdatePrefabDataFilesAsync(this.prefabProject, newVersion);
-                   
-                    this.AvailableVersions.Add(new PrefabVersionViewModel(this.prefabProject, newVersion, fileSystem, referenceManagerFactory));
+                this.AvailableVersions.Insert(indexToInsert, new PrefabVersionViewModel(this.prefabProject, newVersion, fileSystem, referenceManagerFactory));
+                this.wasPublished = true;
 
-                    this.wasDeployed = true;
-                }
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex, ex.Message);
+            }
+        }
 
+        /// <summary>
+        /// Create a copy of selected version and mark the selected version as published.
+        /// </summary>
+        /// <returns></returns>
+        public async Task PublishAsync(PrefabVersionViewModel prefabVersionViewModel)
+        {
+            try
+            {
+                if (prefabVersionViewModel.CanPublish)
+                {
+                    prefabVersionViewModel.Publish(this.workspaceManagerFactory);
+                    await this.applicationDataManager.AddOrUpdatePrefabAsync(this.prefabProject, new PrefabVersion(prefabVersionViewModel.Version) { IsActive = false });
+                    await this.applicationDataManager.AddOrUpdatePrefabDataFilesAsync(this.prefabProject, new PrefabVersion(prefabVersionViewModel.Version) { IsActive = false });
+                    logger.Information($"Version {prefabVersionViewModel.Version} for project : {this.prefabProject.PrefabName} is published now.");
+                }
             }
             catch (Exception ex)
             {
@@ -84,7 +118,7 @@ public async Task Deploy(PrefabVersionViewModel prefabVersionViewModel)
 
         public async Task CloseAsync()
         {
-            await this.TryCloseAsync(this.wasDeployed);
+            await this.TryCloseAsync(this.wasPublished);
         }
     }
 }
diff --git a/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionViewModel.cs b/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionViewModel.cs
index df0bde6d..dd57c6c4 100644
--- a/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionViewModel.cs
+++ b/src/Pixel.Automation.AppExplorer.ViewModels/Prefab/PrefabVersionViewModel.cs
@@ -5,6 +5,7 @@
 using Pixel.Scripting.Editor.Core.Contracts;
 using Pixel.Scripting.Reference.Manager;
 using Pixel.Scripting.Reference.Manager.Contracts;
+using Serilog;
 using System.IO;
 using System.Text.RegularExpressions;
 
@@ -12,6 +13,8 @@ namespace Pixel.Automation.AppExplorer.ViewModels.Prefab
 {
     public class PrefabVersionViewModel : PropertyChangedBase
     {
+        private readonly ILogger logger = Log.ForContext<PrefabVersionViewModel>();
+
         private readonly PrefabProject prefabProject;
         private readonly PrefabVersion prefabVersion;
         private readonly IPrefabFileSystem fileSystem;
@@ -23,18 +26,9 @@ public Version Version
             set => prefabVersion.Version = value;
         }
 
-        public bool IsDeployed
+        public bool IsPublished
         {
-            get => prefabVersion.IsDeployed;
-            set
-            {
-                //can be only set to true when version is not already deployed
-                if (!prefabVersion.IsDeployed && value)
-                {
-                    prefabVersion.IsDeployed = value;
-                }
-                NotifyOfPropertyChange(() => IsDeployed);
-            }
+            get => prefabVersion.IsPublished;            
         }
 
         /// <summary>
@@ -51,16 +45,19 @@ public bool IsActive
                     prefabVersion.IsActive = value;
                 }
                 NotifyOfPropertyChange(() => IsActive);
+                NotifyOfPropertyChange(() => IsPublished);
             }
         }
 
+        public bool CanPublish { get; private set; }
+
 
         public string PrefabAssembly
         {
             get => prefabVersion.DataModelAssembly;
             private set
             {
-                if (prefabVersion.IsDeployed && !string.IsNullOrEmpty(value))
+                if (prefabVersion.IsPublished && !string.IsNullOrEmpty(value))
                 {
                     prefabVersion.DataModelAssembly = value;
                 }
@@ -75,16 +72,28 @@ public PrefabVersionViewModel(PrefabProject prefabProject, PrefabVersion prefabV
             this.prefabVersion = Guard.Argument(prefabVersion, nameof(prefabVersion)).NotNull();
             this.fileSystem = Guard.Argument(fileSystem).NotNull().Value;
             this.referenceManager = new Lazy<ReferenceManager>(() => { return referenceManagerFactory.CreateForPrefabProject(prefabProject, prefabVersion); });
+            this.CanPublish = !prefabVersion.IsPublished && !prefabVersion.Version.Equals(prefabProject.LatestActiveVersion.Version);
         }
 
         public PrefabVersion Clone()
         {
-            ////Increment active version for project        
-            PrefabVersion newVersionInfo = new PrefabVersion(new Version(this.prefabVersion.Version.Major + 1, 0, 0, 0))
+            PrefabVersion newVersionInfo;
+            if (!this.prefabProject.AvailableVersions.Any(a => a.Version.Major.Equals(this.prefabVersion.Version.Major + 1)))
             {
-                IsActive = true,
-                IsDeployed = false
-            };
+                newVersionInfo = new PrefabVersion(new Version(this.prefabVersion.Version.Major + 1, 0, 0, 0))
+                {
+                    IsActive = true
+                };
+            }
+            else
+            {               
+                var versionsWithSameMajor = this.prefabProject.AvailableVersions.Select(s => s.Version).Where(v => v.Major.Equals(this.prefabVersion.Version.Major));
+                int nextMinor = versionsWithSameMajor.Select(v => v.Minor).Max() + 1;
+                newVersionInfo = new PrefabVersion(new Version(this.prefabVersion.Version.Major, nextMinor, 0, 0))
+                {
+                    IsActive = true
+                };
+            }
 
             this.fileSystem.Initialize(this.prefabProject, this.prefabVersion);
             var currentWorkingDirectory = new DirectoryInfo(this.fileSystem.WorkingDirectory);
@@ -109,7 +118,7 @@ void CopyAll(DirectoryInfo source, DirectoryInfo target)
                     CopyAll(diSourceSubDir, nextTargetSubDir);
                 }
             }
-
+            logger.Information($"Completed cloning version : {this.prefabVersion} of Prefab: {this.prefabProject.PrefabName}. Cloned version is : {newVersionInfo}");
             return newVersionInfo;
         }
 
@@ -118,45 +127,53 @@ void CopyAll(DirectoryInfo source, DirectoryInfo target)
         /// Copy last compiled dll from temp folder to References folder.
         /// Set IsDeployed to true and set the assembly name
         /// </summary>
-        public void Deploy(IWorkspaceManagerFactory workspaceFactory)
+        public void Publish(IWorkspaceManagerFactory workspaceFactory)
         {           
-           
-            this.fileSystem.Initialize(this.prefabProject, this.prefabVersion);
-
-            string prefabProjectName = this.prefabProject.PrefabName;
-            ICodeWorkspaceManager workspaceManager = workspaceFactory.CreateCodeWorkspaceManager(this.fileSystem.DataModelDirectory);
-            workspaceManager.WithAssemblyReferences(this.referenceManager.Value.GetCodeEditorReferences());
-            workspaceManager.AddProject(prefabProjectName, this.prefabProject.Namespace, Array.Empty<string>());
-            string[] existingDataModelFiles = Directory.GetFiles(this.fileSystem.DataModelDirectory, "*.cs");
-            if (existingDataModelFiles.Any())
+            if(!this.IsPublished)
             {
-                //This will add all the documents to workspace so that they are available during compilation
-                foreach (var dataModelFile in existingDataModelFiles)
+                this.fileSystem.Initialize(this.prefabProject, this.prefabVersion);
+                logger.Information($"Prefab file system has been initialized.");
+
+                string prefabProjectName = this.prefabProject.PrefabName;
+                ICodeWorkspaceManager workspaceManager = workspaceFactory.CreateCodeWorkspaceManager(this.fileSystem.DataModelDirectory);
+                workspaceManager.WithAssemblyReferences(this.referenceManager.Value.GetCodeEditorReferences());
+                workspaceManager.AddProject(prefabProjectName, this.prefabProject.Namespace, Array.Empty<string>());
+                string[] existingDataModelFiles = Directory.GetFiles(this.fileSystem.DataModelDirectory, "*.cs");
+                if (existingDataModelFiles.Any())
                 {
-                    string documentName = Path.GetFileName(dataModelFile);
-                    if (!workspaceManager.HasDocument(documentName, prefabProjectName))
+                    //This will add all the documents to workspace so that they are available during compilation
+                    foreach (var dataModelFile in existingDataModelFiles)
                     {
-                        workspaceManager.AddDocument(documentName, prefabProjectName, File.ReadAllText(dataModelFile));
+                        string documentName = Path.GetFileName(dataModelFile);
+                        if (!workspaceManager.HasDocument(documentName, prefabProjectName))
+                        {
+                            workspaceManager.AddDocument(documentName, prefabProjectName, File.ReadAllText(dataModelFile));
+                        }
                     }
                 }
-            }
 
-            string assemblyName = this.prefabProject.Namespace;
-            using (var compilationResult = workspaceManager.CompileProject(prefabProjectName, assemblyName))
-            {
-                compilationResult.SaveAssemblyToDisk(this.fileSystem.ReferencesDirectory);
-            }
-            this.IsDeployed = true;
-            this.IsActive = false;
-            this.PrefabAssembly = $"{assemblyName}.dll";
+                string assemblyName = this.prefabProject.Namespace;
+                using (var compilationResult = workspaceManager.CompileProject(prefabProjectName, assemblyName))
+                {
+                    compilationResult.SaveAssemblyToDisk(this.fileSystem.ReferencesDirectory);
+                }
+                logger.Information($"Workspace prepared and compilation done.");
 
-            //Replace the assemly name in the process and template file
-            UpdateAssemblyReference(this.fileSystem.PrefabFile, assemblyName);
-            if(File.Exists(this.fileSystem.TemplateFile))
-            {
-                UpdateAssemblyReference(this.fileSystem.TemplateFile, assemblyName);
-            }
+                this.IsActive = false;
+                this.CanPublish = false;
+                this.PrefabAssembly = $"{assemblyName}.dll";
+
+                //Replace the assemly name in the process and template file
+                UpdateAssemblyReference(this.fileSystem.PrefabFile, assemblyName);
+                if (File.Exists(this.fileSystem.TemplateFile))
+                {
+                    UpdateAssemblyReference(this.fileSystem.TemplateFile, assemblyName);
+                }
+
+                logger.Information($"Assembly references updated in process and template files.");
 
+                NotifyOfPropertyChange(() => CanPublish);
+            }            
         }
 
         /// <summary>
diff --git a/src/Pixel.Automation.AppExplorer.ViewModels/PrefabDropHandler/PrefabVersionSelectorViewModel.cs b/src/Pixel.Automation.AppExplorer.ViewModels/PrefabDropHandler/PrefabVersionSelectorViewModel.cs
index 36048416..8a2d74df 100644
--- a/src/Pixel.Automation.AppExplorer.ViewModels/PrefabDropHandler/PrefabVersionSelectorViewModel.cs
+++ b/src/Pixel.Automation.AppExplorer.ViewModels/PrefabDropHandler/PrefabVersionSelectorViewModel.cs
@@ -100,7 +100,7 @@ public PrefabVersionSelectorViewModel(IProjectFileSystem projectFileSystem, IPre
             {
                 this.prefabReferences = new PrefabReferences();
             }
-            this.AvailableVersions = prefabProject.DeployedVersions;
+            this.AvailableVersions = prefabProject.PublishedVersions;
             this.CanChangeVersion = !prefabReferences.HasReference(prefabProject);
             if(!this.CanChangeVersion)
             {
diff --git a/src/Pixel.Automation.AppExplorer.Views/Prefab/PrefabVersionManagerView.xaml b/src/Pixel.Automation.AppExplorer.Views/Prefab/PrefabVersionManagerView.xaml
index d824382f..f203b128 100644
--- a/src/Pixel.Automation.AppExplorer.Views/Prefab/PrefabVersionManagerView.xaml
+++ b/src/Pixel.Automation.AppExplorer.Views/Prefab/PrefabVersionManagerView.xaml
@@ -41,20 +41,28 @@
                             </DataTemplate>
                         </DataGridTemplateColumn.CellTemplate>
                     </DataGridTemplateColumn>
-                    <DataGridTemplateColumn Header="Is Deployed">
+                    <DataGridTemplateColumn Header="Is Published ?">
                         <DataGridTemplateColumn.CellTemplate>
                             <DataTemplate>
-                                <CheckBox x:Name="Deployed" IsChecked="{Binding IsDeployed, Mode=OneWay}" IsEnabled="False" Margin="5,2,5,2" HorizontalAlignment="Center"  />
+                                <CheckBox x:Name="IsPublished" IsChecked="{Binding IsPublished, Mode=OneWay}" IsEnabled="False" Margin="5,2,5,2" HorizontalAlignment="Center"  />
                             </DataTemplate>
                         </DataGridTemplateColumn.CellTemplate>
                     </DataGridTemplateColumn>
-                    <DataGridTemplateColumn Header="Deploy">
+                    <DataGridTemplateColumn Header="">
                         <DataGridTemplateColumn.CellTemplate>
                             <DataTemplate>
-                                <StackPanel Visibility="{Binding IsActive, Converter={StaticResource boolToVisConverter}}">
-                                    <Button x:Name="Deploy" Content="DEPLOY" cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=DataGrid}}"
-                                        cal:Message.Attach="[Event Click] = [Action Deploy($dataContext)]" Margin="5,2,5,2" HorizontalAlignment="Center" ToolTip="Deploy this version and create an incremented cloned version"  />
-                                </StackPanel>                                
+                                <Button x:Name="CloneAndPublish" Content="Clone and Publish" cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=DataGrid}}"
+                                        cal:Message.Attach="[Event Click] = [Action CloneAndPublishAsync($dataContext)]" Margin="5,2,5,2" HorizontalAlignment="Center" ToolTip="Create a copy with incremented version and mark this version published."  />
+                            </DataTemplate>
+                        </DataGridTemplateColumn.CellTemplate>
+                    </DataGridTemplateColumn>
+                    <DataGridTemplateColumn Header="">
+                        <DataGridTemplateColumn.CellTemplate>
+                            <DataTemplate>
+                                <Button x:Name="Publish" Content="Publish" IsEnabled="{Binding CanPublish}"
+                                        cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=DataGrid}}"
+                                        cal:Message.Attach="[Event Click] = [Action PublishAsync($dataContext)]" Margin="5,2,5,2" HorizontalAlignment="Center"
+                                        ToolTip="Mark the version as published. Published versions can be used in automation."  />
                             </DataTemplate>
                         </DataGridTemplateColumn.CellTemplate>
                     </DataGridTemplateColumn>
diff --git a/src/Pixel.Automation.Core/Models/AutomationProject.cs b/src/Pixel.Automation.Core/Models/AutomationProject.cs
index 82c44f4c..9f91780c 100644
--- a/src/Pixel.Automation.Core/Models/AutomationProject.cs
+++ b/src/Pixel.Automation.Core/Models/AutomationProject.cs
@@ -32,18 +32,23 @@ public class AutomationProject
       
         [DataMember(IsRequired = true, Order = 50)]
         public List<ProjectVersion> AvailableVersions { get; } = new List<ProjectVersion>();
-
+       
         /// <summary>
-        /// Get all the versions that are deployed.
+        /// Get all the versions that are active.
         /// </summary>
-        public IEnumerable<ProjectVersion> DeployedVersions { get => AvailableVersions.Where(a => a.IsDeployed).ToList(); }
+        public IEnumerable<ProjectVersion> ActiveVersions { get => AvailableVersions.Where(a => a.IsActive).ToList(); }
 
         /// <summary>
-        /// Active version of the project
+        /// Get all the versions that are published.
+        /// </summary>
+        public IEnumerable<ProjectVersion> PublishedVersions { get => AvailableVersions.Where(a => a.IsPublished).ToList(); }
+       
+        /// <summary>
+        /// Latest Active version of the project
         /// </summary>
-        public ProjectVersion ActiveVersion
+        public ProjectVersion LatestActiveVersion
         {
-            get => this.AvailableVersions.FirstOrDefault(a => a.IsActive);
+            get => this.ActiveVersions.OrderBy(a => a.Version).LastOrDefault();
         }
 
         /// <summary>
diff --git a/src/Pixel.Automation.Core/Models/PrefabProject.cs b/src/Pixel.Automation.Core/Models/PrefabProject.cs
index d7e84cc8..f5666cc7 100644
--- a/src/Pixel.Automation.Core/Models/PrefabProject.cs
+++ b/src/Pixel.Automation.Core/Models/PrefabProject.cs
@@ -49,13 +49,21 @@ public class PrefabProject : ICloneable
         public string GroupName { get; set; } = "Default";
 
         /// <summary>
-        /// Get all the versions that are deployed. Deployed Prefabs can be used in an automation.
+        /// Get all the versions that are active.
         /// </summary>
-        public IEnumerable<PrefabVersion> DeployedVersions { get => AvailableVersions.Where(a => a.IsDeployed).ToList(); }
+        public IEnumerable<PrefabVersion> ActiveVersions { get => AvailableVersions.Where(a => a.IsActive).ToList(); }
 
-        public PrefabVersion ActiveVersion
+        /// <summary>
+        /// Get all the versions that are published. Published Prefabs can be used in an automation.
+        /// </summary>
+        public IEnumerable<PrefabVersion> PublishedVersions { get => AvailableVersions.Where(a => a.IsPublished).ToList(); }             
+       
+        /// <summary>
+        /// Latest Active version of the project
+        /// </summary>
+        public PrefabVersion LatestActiveVersion
         {
-            get => this.AvailableVersions.FirstOrDefault(a => a.IsActive);
+            get => this.ActiveVersions.OrderBy(a => a.Version).LastOrDefault();
         }
 
         public Interfaces.IComponent PrefabRoot { get; set; }
diff --git a/src/Pixel.Automation.Core/Models/VersionInfo.cs b/src/Pixel.Automation.Core/Models/VersionInfo.cs
index 6aafadb7..d25bf668 100644
--- a/src/Pixel.Automation.Core/Models/VersionInfo.cs
+++ b/src/Pixel.Automation.Core/Models/VersionInfo.cs
@@ -15,31 +15,27 @@ public abstract class VersionInfo
         /// </summary>
         [DataMember(IsRequired = true, Order = 10)]
         public Version Version { get; set; }
-
-        /// <summary>
-        /// Indicates if the version is deployed
-        /// </summary>
-        [DataMember(IsRequired = true, Order = 20)]
-        public bool IsDeployed { get; set; } = false;
-
+      
         /// <summary>
         /// Indicates if the version is active
         /// </summary>
-        [DataMember(IsRequired = true, Order = 30)]
+        [DataMember(IsRequired = true, Order = 20)]
         public bool IsActive { get; set; } = true;
 
         /// <summary>
         /// Data model assembly name for the automation or prefab project
         /// </summary>
-        [DataMember(IsRequired = false, Order = 40)]
+        [DataMember(IsRequired = false, Order = 30)]
         public string DataModelAssembly { get; set; }
 
         /// <summary>
         /// Description 
         /// </summary>
-        [DataMember(IsRequired = false, Order = 50)]
+        [DataMember(IsRequired = false, Order = 40)]
         public string Description { get; set; }
 
+        public bool IsPublished => !this.IsActive;
+
         ///</inheritdoc>
         public override bool Equals(object obj)
         {
diff --git a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationEditorViewModel.cs b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationEditorViewModel.cs
index 2a6a4942..54e9f861 100644
--- a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationEditorViewModel.cs
+++ b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/AutomationEditorViewModel.cs
@@ -77,7 +77,7 @@ public async Task DoLoad(AutomationProject project, VersionInfo versionToLoad =
             this.DisplayName = project.Name;
 
             //Always open the most recent non-deployed version if no version is specified
-            var targetVersion = versionToLoad ?? project.ActiveVersion;
+            var targetVersion = versionToLoad ?? project.LatestActiveVersion;
             logger.Information($"Version : {targetVersion} will be loaded.");
             if(targetVersion != null)
             {
diff --git a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabEditorViewModel.cs b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabEditorViewModel.cs
index 7c2ad883..cbe9e0c5 100644
--- a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabEditorViewModel.cs
+++ b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabEditorViewModel.cs
@@ -41,7 +41,7 @@ public virtual void DoLoad(PrefabProject prefabProject, VersionInfo versionToLoa
             this.PrefabProject = prefabProject;
             this.DisplayName = prefabProject.PrefabName;
 
-            var targetVersion = versionToLoad ?? PrefabProject.ActiveVersion;
+            var targetVersion = versionToLoad ?? PrefabProject.LatestActiveVersion;
             if (targetVersion != null)
             {
                 this.projectManager.Load(prefabProject, targetVersion);
@@ -100,7 +100,7 @@ public async override Task ManageProjectVersionAsync()
             if(result.HasValue && result.Value)
             {
                 var fileSystem = this.projectManager.GetProjectFileSystem() as IVersionedFileSystem;
-                fileSystem.SwitchToVersion(this.PrefabProject.ActiveVersion);
+                fileSystem.SwitchToVersion(this.PrefabProject.LatestActiveVersion);
 
                 //This will update Code editor and script editor to point to the new workspace directory
                 //This will update Code editor and script editor to point to the new workspace directory
diff --git a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabProjectManager.cs b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabProjectManager.cs
index b163a1fa..8ae9f26a 100644
--- a/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabProjectManager.cs
+++ b/src/Pixel.Automation.Designer.ViewModels/AutomationBuilder/PrefabProjectManager.cs
@@ -199,8 +199,8 @@ public override async Task Save()
             prefabParent.AddComponent(this.prefabbedEntity);
 
             //push the changes to database
-            await this.applicationDataManager.AddOrUpdatePrefabAsync(this.prefabProject, this.prefabProject.ActiveVersion);
-            await this.applicationDataManager.AddOrUpdatePrefabDataFilesAsync(this.prefabProject, this.prefabProject.ActiveVersion);
+            await this.applicationDataManager.AddOrUpdatePrefabAsync(this.prefabProject, this.prefabProject.LatestActiveVersion);
+            await this.applicationDataManager.AddOrUpdatePrefabDataFilesAsync(this.prefabProject, this.prefabProject.LatestActiveVersion);
         }
 
 
diff --git a/src/Pixel.Automation.Designer.ViewModels/DragDropHandlers/ComponentDragHandler.cs b/src/Pixel.Automation.Designer.ViewModels/DragDropHandlers/ComponentDragHandler.cs
index 8d5be315..1fa8c0f3 100644
--- a/src/Pixel.Automation.Designer.ViewModels/DragDropHandlers/ComponentDragHandler.cs
+++ b/src/Pixel.Automation.Designer.ViewModels/DragDropHandlers/ComponentDragHandler.cs
@@ -118,7 +118,7 @@ public void DragOver(IDropInfo dropInfo)
                 {
                     if (dropInfo.VisualTarget is FrameworkElement fe && fe.DataContext.GetType() == typeof(AutomationEditorViewModel))
                     {
-                        if (prefabProject.DeployedVersions.Any())
+                        if (prefabProject.PublishedVersion.Any())
                         {
                             dropInfo.DropTargetAdorner = DropTargetAdorners.Highlight;
                             dropInfo.Effects = DragDropEffects.Copy;
diff --git a/src/Pixel.Automation.Designer.ViewModels/Screen/AutomationProjectViewModel.cs b/src/Pixel.Automation.Designer.ViewModels/Screen/AutomationProjectViewModel.cs
index 552c3020..9bef3bc7 100644
--- a/src/Pixel.Automation.Designer.ViewModels/Screen/AutomationProjectViewModel.cs
+++ b/src/Pixel.Automation.Designer.ViewModels/Screen/AutomationProjectViewModel.cs
@@ -71,8 +71,8 @@ public bool IsOpenInEditor
         public AutomationProjectViewModel(AutomationProject automationProject)
         {
             this.automationProject = automationProject;
-            this.EditableVersions.AddRange(automationProject.AvailableVersions.Where(a => !a.IsDeployed));
-            this.SelectedVersion = automationProject.ActiveVersion;
+            this.EditableVersions.AddRange(automationProject.ActiveVersions);
+            this.SelectedVersion = automationProject.LatestActiveVersion;
         }
     }
 }
diff --git a/src/Pixel.Automation.Designer.ViewModels/Screen/NewProjectViewModel.cs b/src/Pixel.Automation.Designer.ViewModels/Screen/NewProjectViewModel.cs
index 2b1dd5a0..db061e19 100644
--- a/src/Pixel.Automation.Designer.ViewModels/Screen/NewProjectViewModel.cs
+++ b/src/Pixel.Automation.Designer.ViewModels/Screen/NewProjectViewModel.cs
@@ -1,5 +1,4 @@
 using Dawn;
-using Newtonsoft.Json.Linq;
 using Pixel.Automation.Core;
 using Pixel.Automation.Core.Interfaces;
 using Pixel.Automation.Core.Models;
@@ -44,7 +43,7 @@ public NewProjectViewModel(ISerializer serializer, IApplicationDataManager appli
 
             Version defaultVersion = new Version(1, 0, 0, 0);
             this.NewProject = new AutomationProject();
-            this.NewProject.AvailableVersions.Add(new ProjectVersion(defaultVersion) { IsActive = true, IsDeployed = false});
+            this.NewProject.AvailableVersions.Add(new ProjectVersion(defaultVersion) { IsActive = true});
 
             this.existingProjects.AddRange(this.applicationDataManager.GetAllProjects());
         
diff --git a/src/Pixel.Automation.Designer.ViewModels/VersionManager/PrefabReferenceViewModel.cs b/src/Pixel.Automation.Designer.ViewModels/VersionManager/PrefabReferenceViewModel.cs
index 4f3f711f..d3de77d4 100644
--- a/src/Pixel.Automation.Designer.ViewModels/VersionManager/PrefabReferenceViewModel.cs
+++ b/src/Pixel.Automation.Designer.ViewModels/VersionManager/PrefabReferenceViewModel.cs
@@ -34,7 +34,7 @@ public PrefabReferenceViewModel(PrefabProject prefabProject, PrefabReference pre
             this.prefabReference = Guard.Argument(prefabReference).NotNull();
             this.PrefabName = prefabProject.PrefabName;
             this.VersionInUse = prefabReference.Version.ToString();
-            foreach (var version in prefabProject.DeployedVersions)
+            foreach (var version in prefabProject.PublishedVersions)
             {
                 this.AvailableVersions.Add(version);
             }
diff --git a/src/Pixel.Automation.Designer.ViewModels/VersionManager/ProjectVersionManagerViewModel.cs b/src/Pixel.Automation.Designer.ViewModels/VersionManager/ProjectVersionManagerViewModel.cs
index 8ddb5d00..a34d3b25 100644
--- a/src/Pixel.Automation.Designer.ViewModels/VersionManager/ProjectVersionManagerViewModel.cs
+++ b/src/Pixel.Automation.Designer.ViewModels/VersionManager/ProjectVersionManagerViewModel.cs
@@ -22,14 +22,14 @@ public class ProjectVersionManagerViewModel: Caliburn.Micro.Screen, IVersionMana
         private readonly AutomationProject automationProject;
         private readonly ApplicationSettings applicationSettings;
 
-        private bool wasDeployed;
+        private bool wasPublished;
 
         public BindableCollection<ProjectVersionViewModel> AvailableVersions { get; set; } = new BindableCollection<ProjectVersionViewModel>();
        
         public ProjectVersionManagerViewModel(AutomationProject automationProject, IWorkspaceManagerFactory workspaceManagerFactory,
             IReferenceManagerFactory referenceManagerFactory, ISerializer serializer, IApplicationDataManager applicationDataManager, ApplicationSettings applicationSettings)
         {
-            this.DisplayName = "Manage & Deploy Versions";
+            this.DisplayName = "Manage Project Versions";
             this.workspaceManagerFactory = Guard.Argument(workspaceManagerFactory, nameof(workspaceManagerFactory)).NotNull().Value;
             this.referenceManagerFactory = Guard.Argument(referenceManagerFactory, nameof(referenceManagerFactory)).NotNull().Value;
             this.serializer = Guard.Argument(serializer, nameof(serializer)).NotNull().Value;
@@ -44,36 +44,45 @@ public ProjectVersionManagerViewModel(AutomationProject automationProject, IWork
         }
 
         /// <summary>
-        /// Create a copy of selected version and deploy the selected version.
+        /// Create a copy of selected version and mark the selected version as Published.
         /// </summary>
         /// <returns></returns>
-        public async Task Deploy(ProjectVersionViewModel projectVersionViewModel)
+        public async Task CloneAndPublishAsync(ProjectVersionViewModel projectVersionViewModel)
         {
             try
-            {               
-                if (projectVersionViewModel?.IsActive == true)
-                {
-                    logger.Information($"Trying to deploy version {projectVersionViewModel.Version} for project : {this.automationProject.Name}");
-                  
-                    //Create a new active version from selected version
-                    ProjectVersion newVersion = projectVersionViewModel.Clone();
-                    IProjectFileSystem projectFileSystem = new ProjectFileSystem(serializer, this.applicationSettings);
-                    projectFileSystem.Initialize(this.automationProject, newVersion);
+            {
+                logger.Information($"Trying to clone version {projectVersionViewModel.Version} for Project : {this.automationProject.Name}");
 
-                    //Deploy the selected version
-                    projectVersionViewModel.Deploy(this.workspaceManagerFactory);                   
+                //Create a new active version from selected version
+                ProjectVersion newVersion = projectVersionViewModel.Clone();
+                IProjectFileSystem projectFileSystem = new ProjectFileSystem(serializer, this.applicationSettings);
+                projectFileSystem.Initialize(this.automationProject, newVersion);
 
-                    this.automationProject.AvailableVersions.Add(newVersion);
-                    serializer.Serialize<AutomationProject>(projectFileSystem.ProjectFile, this.automationProject);
+                //After cloning, we mark the curret version as published
+                if(!projectVersionViewModel.IsPublished)
+                {
+                    projectVersionViewModel.Publish(this.workspaceManagerFactory);
+                    logger.Information($"Version {projectVersionViewModel.Version} for project : {this.automationProject.Name} is published now.");
+                }
 
-                    await this.applicationDataManager.AddOrUpdateProjectAsync(this.automationProject, projectVersionViewModel.ProjectVersion);
-                    await this.applicationDataManager.AddOrUpdateProjectAsync(this.automationProject, newVersion);
-                   
-                    this.AvailableVersions.Add(new ProjectVersionViewModel(this.automationProject, newVersion, projectFileSystem, referenceManagerFactory));
-                    logger.Information($"Completed deployment of version : {projectVersionViewModel.Version} for project : {this.automationProject.Name}");
+                int indexToInsert = 0;
+                foreach(var version in this.automationProject.AvailableVersions.Select(s => s.Version))
+                {
+                    if(version < newVersion.Version)
+                    {
+                        indexToInsert++;
+                        continue;
+                    }                               
+                    break;
+                }
+                this.automationProject.AvailableVersions.Insert(indexToInsert, newVersion);
+                serializer.Serialize<AutomationProject>(projectFileSystem.ProjectFile, this.automationProject);
 
-                    this.wasDeployed = true;
-                }              
+                await this.applicationDataManager.AddOrUpdateProjectAsync(this.automationProject, projectVersionViewModel.ProjectVersion);
+                await this.applicationDataManager.AddOrUpdateProjectAsync(this.automationProject, newVersion);
+
+                this.AvailableVersions.Insert(indexToInsert, new ProjectVersionViewModel(this.automationProject, newVersion, projectFileSystem, referenceManagerFactory));
+                this.wasPublished = true;
             }
             catch (Exception ex)
             {
@@ -81,9 +90,31 @@ public async Task Deploy(ProjectVersionViewModel projectVersionViewModel)
             }           
         }
 
+        /// <summary>
+        /// Create a copy of selected version and mark the selected version as Published.
+        /// </summary>
+        /// <returns></returns>
+        public async Task PublishAsync(ProjectVersionViewModel projectVersionViewModel)
+        {
+            try
+            {               
+                if (projectVersionViewModel.CanPublish)
+                {
+                    projectVersionViewModel.Publish(this.workspaceManagerFactory);
+                    await this.applicationDataManager.AddOrUpdateProjectAsync(this.automationProject, projectVersionViewModel.ProjectVersion);
+                    logger.Information($"Version {projectVersionViewModel.Version} for project : {this.automationProject.Name} is published now.");
+                }                              
+            }
+            catch (Exception ex)
+            {
+                logger.Error(ex, ex.Message);
+            }
+        }
+
+
         public async Task CloseAsync()
         {
-            await this.TryCloseAsync(this.wasDeployed);
+            await this.TryCloseAsync(this.wasPublished);
         }
     }
 }
diff --git a/src/Pixel.Automation.Designer.ViewModels/VersionManager/ProjectVersionViewModel.cs b/src/Pixel.Automation.Designer.ViewModels/VersionManager/ProjectVersionViewModel.cs
index 3d512ff8..3a0da5fd 100644
--- a/src/Pixel.Automation.Designer.ViewModels/VersionManager/ProjectVersionViewModel.cs
+++ b/src/Pixel.Automation.Designer.ViewModels/VersionManager/ProjectVersionViewModel.cs
@@ -27,18 +27,9 @@ public Version Version
             set => ProjectVersion.Version = value;
         }
 
-        public bool IsDeployed
+        public bool IsPublished
         {
-            get => ProjectVersion.IsDeployed;
-            set
-            {
-                //can be only set to true when version is not already deployed
-                if (!ProjectVersion.IsDeployed && value)
-                {
-                    ProjectVersion.IsDeployed = value;
-                }
-                NotifyOfPropertyChange(() => IsDeployed);
-            }
+            get => ProjectVersion.IsPublished;            
         }
 
         /// <summary>
@@ -55,16 +46,18 @@ public bool IsActive
                     ProjectVersion.IsActive = value;
                 }
                 NotifyOfPropertyChange(() => IsActive);
+                NotifyOfPropertyChange(() => IsPublished);               
             }
         }
 
-
+        public bool CanPublish { get; private set; }
+        
         public string DataModelAssembly
         {
             get => ProjectVersion.DataModelAssembly;
             private set
             {
-                if (ProjectVersion.IsDeployed && !string.IsNullOrEmpty(value))
+                if (ProjectVersion.IsPublished && !string.IsNullOrEmpty(value))
                 {
                     ProjectVersion.DataModelAssembly = value;
                 }
@@ -79,19 +72,29 @@ public ProjectVersionViewModel(AutomationProject automationProject, ProjectVersi
             this.ProjectVersion = Guard.Argument(projectVersion, nameof(projectVersion)).NotNull();
             this.fileSystem = Guard.Argument(fileSystem).NotNull().Value;
             this.referenceManager = new Lazy<ReferenceManager>(() => { return referenceManagerFactory.CreateForAutomationProject(automationProject, projectVersion); });
+            this.CanPublish = !projectVersion.IsPublished && !projectVersion.Version.Equals(automationProject.LatestActiveVersion.Version);
         }
 
 
         public ProjectVersion Clone()
-        {
-            logger.Information($"Trying to clone version : {this.ProjectVersion} of project: {this.automationProject.Name}");
-            ////Increment active version for project        
-            ProjectVersion newVersionInfo = new ProjectVersion(new Version(this.ProjectVersion.Version.Major + 1, 0, 0, 0))
+        {            
+            ProjectVersion newVersionInfo;
+            if (!this.automationProject.AvailableVersions.Any(a => a.Version.Major.Equals(this.ProjectVersion.Version.Major + 1)))
             {
-                IsActive = true,
-                IsDeployed = false
-            };
-
+                newVersionInfo = new ProjectVersion(new Version(this.ProjectVersion.Version.Major + 1, 0, 0, 0))
+                {
+                    IsActive = true
+                };
+            }
+            else
+            {
+                var versionsWithSameMajor = this.automationProject.AvailableVersions.Select(s => s.Version).Where(v => v.Major.Equals(this.ProjectVersion.Version.Major));
+                int nextMinor = versionsWithSameMajor.Select(v => v.Minor).Max() + 1;
+                newVersionInfo = new ProjectVersion(new Version(this.ProjectVersion.Version.Major, nextMinor, 0, 0))
+                {
+                    IsActive = true
+                };
+            }       
             this.fileSystem.Initialize(this.automationProject, this.ProjectVersion);
             var currentWorkingDirectory = new DirectoryInfo(this.fileSystem.WorkingDirectory);
             var newWorkingDirectory = Path.Combine(currentWorkingDirectory.Parent.FullName, newVersionInfo.ToString());
@@ -122,61 +125,63 @@ void CopyAll(DirectoryInfo source, DirectoryInfo target)
 
         /// <summary>
         /// Copy last compiled dll from temp folder to References folder.
-        /// Set IsDeployed to true and set the assembly name
+        /// Set IsActive to false and set the assembly name
         /// </summary>
-        public void Deploy(IWorkspaceManagerFactory workspaceFactory)
+        public void Publish(IWorkspaceManagerFactory workspaceFactory)
         {          
-
-            this.fileSystem.Initialize(this.automationProject, this.ProjectVersion);
-            logger.Information($"Project file system has been initialized.");
-
-            ICodeWorkspaceManager workspaceManager = workspaceFactory.CreateCodeWorkspaceManager(this.fileSystem.DataModelDirectory);
-            workspaceManager.WithAssemblyReferences(this.referenceManager.Value.GetCodeEditorReferences());
-            workspaceManager.AddProject(this.automationProject.Name, this.automationProject.Namespace, Array.Empty<string>());
-            string[] existingDataModelFiles = Directory.GetFiles(this.fileSystem.DataModelDirectory, "*.cs");
-            if (existingDataModelFiles.Any())
+            if(!this.IsPublished)
             {
-                //This will add all the documents to workspace so that they are available during compilation
-                foreach (var dataModelFile in existingDataModelFiles)
+                this.fileSystem.Initialize(this.automationProject, this.ProjectVersion);
+                logger.Information($"Project file system has been initialized.");
+
+                ICodeWorkspaceManager workspaceManager = workspaceFactory.CreateCodeWorkspaceManager(this.fileSystem.DataModelDirectory);
+                workspaceManager.WithAssemblyReferences(this.referenceManager.Value.GetCodeEditorReferences());
+                workspaceManager.AddProject(this.automationProject.Name, this.automationProject.Namespace, Array.Empty<string>());
+                string[] existingDataModelFiles = Directory.GetFiles(this.fileSystem.DataModelDirectory, "*.cs");
+                if (existingDataModelFiles.Any())
                 {
-                    string documentName = Path.GetFileName(dataModelFile);
-                    if (!workspaceManager.HasDocument(documentName, this.automationProject.Name))
+                    //This will add all the documents to workspace so that they are available during compilation
+                    foreach (var dataModelFile in existingDataModelFiles)
                     {
-                        workspaceManager.AddDocument(documentName, this.automationProject.Name, File.ReadAllText(dataModelFile));
+                        string documentName = Path.GetFileName(dataModelFile);
+                        if (!workspaceManager.HasDocument(documentName, this.automationProject.Name))
+                        {
+                            workspaceManager.AddDocument(documentName, this.automationProject.Name, File.ReadAllText(dataModelFile));
+                        }
                     }
                 }
-            }
 
-            string assemblyName = this.automationProject.Namespace;
-            using (var compilationResult = workspaceManager.CompileProject(this.automationProject.Name, assemblyName))
-            {
-                compilationResult.SaveAssemblyToDisk(this.fileSystem.ReferencesDirectory);            
-            }
-
-            logger.Information($"Workspace prepared and compilation done.");
+                string assemblyName = this.automationProject.Namespace;
+                using (var compilationResult = workspaceManager.CompileProject(this.automationProject.Name, assemblyName))
+                {
+                    compilationResult.SaveAssemblyToDisk(this.fileSystem.ReferencesDirectory);
+                }
 
-            this.IsDeployed = true;
-            this.IsActive = false;
-            this.DataModelAssembly = $"{assemblyName}.dll";
+                logger.Information($"Workspace prepared and compilation done.");
 
-            logger.Information($"Data model assembly name is : {this.DataModelAssembly}");
+                this.IsActive = false;
+                this.CanPublish = false;
+                this.DataModelAssembly = $"{assemblyName}.dll";
 
-            //Replace the assemly name in the process file
-            UpdateAssemblyReference(this.fileSystem.ProcessFile, assemblyName);
+                logger.Information($"Data model assembly name is : {this.DataModelAssembly}");
 
-            logger.Information($"Assembly references updated in process file.");
+                //Replace the assemly name in the process file
+                UpdateAssemblyReference(this.fileSystem.ProcessFile, assemblyName);
 
-            //Replace the assembly name in all of the test process file
-            foreach (var directory in Directory.GetDirectories(this.fileSystem.TestCaseRepository))
-            {
-                var testProcessFile = Directory.GetFiles(directory, "*.proc").FirstOrDefault();
-                if(testProcessFile != null)
+                //Replace the assembly name in all of the test process file
+                foreach (var directory in Directory.GetDirectories(this.fileSystem.TestCaseRepository))
                 {
-                    UpdateAssemblyReference(testProcessFile, assemblyName);
+                    var testProcessFile = Directory.GetFiles(directory, "*.proc").FirstOrDefault();
+                    if (testProcessFile != null)
+                    {
+                        UpdateAssemblyReference(testProcessFile, assemblyName);
+                    }
                 }
-            }
 
-            logger.Information($"Assembly references updated in all test cases.");
+                logger.Information($"Assembly references updated in process and test files.");
+
+                NotifyOfPropertyChange(() => CanPublish);
+            }            
         }
 
         /// <summary>
diff --git a/src/Pixel.Automation.Designer.Views/VersionManager/ProjectVersionManagerView.xaml b/src/Pixel.Automation.Designer.Views/VersionManager/ProjectVersionManagerView.xaml
index e6abaf6f..1067e4db 100644
--- a/src/Pixel.Automation.Designer.Views/VersionManager/ProjectVersionManagerView.xaml
+++ b/src/Pixel.Automation.Designer.Views/VersionManager/ProjectVersionManagerView.xaml
@@ -2,12 +2,10 @@
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
-             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
-             xmlns:local="clr-namespace:Pixel.Automation.Designer.Views.VersionManager"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"            
              xmlns:controls="clr-namespace:MahApps.Metro.Controls;assembly=MahApps.Metro"
              xmlns:converters="clr-namespace:Pixel.Automation.Editor.Core.Converters;assembly=Pixel.Automation.Editor.Core"
-             xmlns:cal="http://www.caliburnproject.org" cal:Bind.AtDesignTime="True"
-             xmlns:xctk="http://schemas.xceed.com/wpf/xaml/toolkit"
+             xmlns:cal="http://www.caliburnproject.org" cal:Bind.AtDesignTime="True"          
              mc:Ignorable="d"  ResizeMode="NoResize" SizeToContent="WidthAndHeight"
              WindowStartupLocation="CenterScreen"  GlowBrush="{DynamicResource AccentColorBrush}"
              MinHeight="400" MaxHeight="600" ShowCloseButton="False"
@@ -42,20 +40,28 @@
                             </DataTemplate>
                         </DataGridTemplateColumn.CellTemplate>
                     </DataGridTemplateColumn>
-                    <DataGridTemplateColumn Header="Is Deployed">
+                    <DataGridTemplateColumn Header="Is Published ?">
                         <DataGridTemplateColumn.CellTemplate>
                             <DataTemplate>
-                                <CheckBox x:Name="Deployed" IsChecked="{Binding IsDeployed, Mode=OneWay}" IsEnabled="False" Margin="5,2,5,2" HorizontalAlignment="Center"  />
+                                <CheckBox x:Name="IsPublished" IsChecked="{Binding IsPublished, Mode=OneWay}" IsEnabled="False" Margin="5,2,5,2" HorizontalAlignment="Center"  />
                             </DataTemplate>
                         </DataGridTemplateColumn.CellTemplate>
                     </DataGridTemplateColumn>
-                    <DataGridTemplateColumn Header="Deploy">
+                    <DataGridTemplateColumn Header="">
                         <DataGridTemplateColumn.CellTemplate>
                             <DataTemplate>
-                                <StackPanel Visibility="{Binding IsActive, Converter={StaticResource boolToVisConverter}}">
-                                    <Button x:Name="Deploy" Content="DEPLOY" cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=DataGrid}}"
-                                        cal:Message.Attach="[Event Click] = [Action Deploy($dataContext)]" Margin="5,2,5,2" HorizontalAlignment="Center" ToolTip="Deploy this version and create an incremented cloned version"  />
-                                </StackPanel>
+                                <Button x:Name="CloneAndPublish" Content="Clone and Publish" cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=DataGrid}}"
+                                        cal:Message.Attach="[Event Click] = [Action CloneAndPublishAsync($dataContext)]" Margin="5,2,5,2" HorizontalAlignment="Center" ToolTip="Create a copy of this version and mark this version read only" />
+                            </DataTemplate>
+                        </DataGridTemplateColumn.CellTemplate>
+                    </DataGridTemplateColumn>
+                    <DataGridTemplateColumn Header="">
+                        <DataGridTemplateColumn.CellTemplate>
+                            <DataTemplate>
+                                <Button x:Name="Publish" Content="Publish" IsEnabled="{Binding CanPublish}"
+                                        cal:Action.TargetWithoutContext="{Binding Path=DataContext, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=DataGrid}}"
+                                        cal:Message.Attach="[Event Click] = [Action PublishAsync($dataContext)]" Margin="5,2,5,2" 
+                                        HorizontalAlignment="Center" ToolTip="Mark this version as read only" />
                             </DataTemplate>
                         </DataGridTemplateColumn.CellTemplate>
                     </DataGridTemplateColumn>
diff --git a/src/Pixel.Automation.Test.Runner/ProjectManager.cs b/src/Pixel.Automation.Test.Runner/ProjectManager.cs
index 2619a33e..6df856c4 100644
--- a/src/Pixel.Automation.Test.Runner/ProjectManager.cs
+++ b/src/Pixel.Automation.Test.Runner/ProjectManager.cs
@@ -101,7 +101,7 @@ public async Task LoadProjectAsync(string projectId, string projectVersion, stri
 
             object dataModel;
             //Load the setup data model for the project.
-            if(this.targetVersion.IsDeployed)
+            if(this.targetVersion.IsPublished)
             {
                 Assembly dataModelAssembly = Assembly.LoadFrom(Path.Combine(projectFileSystem.ReferencesDirectory, targetVersion.DataModelAssembly));
                 Type setupDataModel = dataModelAssembly.GetTypes().FirstOrDefault(t => t.Name.Equals(Constants.AutomationProcessDataModelName)) ?? throw new Exception($"Data model assembly {dataModelAssembly.GetName().Name} doesn't contain  type : {Constants.AutomationProcessDataModelName}");
diff --git a/src/Pixel.Persistence.Core/Models/ApplicationMetaData.cs b/src/Pixel.Persistence.Core/Models/ApplicationMetaData.cs
index 92f49ed6..b86af34b 100644
--- a/src/Pixel.Persistence.Core/Models/ApplicationMetaData.cs
+++ b/src/Pixel.Persistence.Core/Models/ApplicationMetaData.cs
@@ -28,16 +28,16 @@ public class ApplicationMetaData
         [DataMember]
         public List<PrefabMetaDataCompact> PrefabsMeta { get; set; } = new List<PrefabMetaDataCompact>();
 
-        public void AddOrUpdatePrefabMetaData(string prefabId, string version, bool isDeployed)
+        public void AddOrUpdatePrefabMetaData(string prefabId, string version, bool isActive)
         {
             var prefabMetaDataEntry = PrefabsMeta.FirstOrDefault(p => p.PrefabId.Equals(prefabId));
             if(prefabMetaDataEntry != null)
             {
-                prefabMetaDataEntry.AddOrUpdateVersionMetaData(new PrefabVersionMetaData() { Version = version, IsDeployed = isDeployed, IsActive = !isDeployed, LastUpdated = DateTime.UtcNow });
+                prefabMetaDataEntry.AddOrUpdateVersionMetaData(new PrefabVersionMetaData() { Version = version, IsActive = isActive, LastUpdated = DateTime.UtcNow });
                 return;
             }
             var prefabMetaData = new PrefabMetaDataCompact() { PrefabId = prefabId };
-            prefabMetaData.AddOrUpdateVersionMetaData(new PrefabVersionMetaData() { Version = version, IsDeployed = isDeployed, IsActive = !isDeployed, LastUpdated = DateTime.UtcNow });
+            prefabMetaData.AddOrUpdateVersionMetaData(new PrefabVersionMetaData() { Version = version, IsActive = isActive, LastUpdated = DateTime.UtcNow });
             this.PrefabsMeta.Add(prefabMetaData);
         }
                
diff --git a/src/Pixel.Persistence.Core/Models/PrefabMetaData.cs b/src/Pixel.Persistence.Core/Models/PrefabMetaData.cs
index a1757fa1..c396eec5 100644
--- a/src/Pixel.Persistence.Core/Models/PrefabMetaData.cs
+++ b/src/Pixel.Persistence.Core/Models/PrefabMetaData.cs
@@ -26,9 +26,6 @@ public class PrefabMetaData
         [DataMember]
         public bool IsActive { get; set; }
 
-        [DataMember]
-        public bool IsDeployed { get; set; }
-
     }
 
     [DataContract]
@@ -68,9 +65,6 @@ public class PrefabVersionMetaData
         [DataMember]
         public bool IsActive { get; set; }
 
-        [DataMember]
-        public bool IsDeployed { get; set; }
-
         [DataMember]
         public DateTime LastUpdated { get; set; }
     }
diff --git a/src/Pixel.Persistence.Core/Models/ProjectMetaData.cs b/src/Pixel.Persistence.Core/Models/ProjectMetaData.cs
index c8131383..a1a88374 100644
--- a/src/Pixel.Persistence.Core/Models/ProjectMetaData.cs
+++ b/src/Pixel.Persistence.Core/Models/ProjectMetaData.cs
@@ -1,7 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
-using System.Text;
 
 namespace Pixel.Persistence.Core.Models
 {
@@ -16,8 +14,6 @@ public class ProjectMetaData
 
         public bool IsActive { get; set; }
 
-        public bool IsDeployed { get; set; }
-
         public DateTime LastUpdated { get; set; }
     }
 }
diff --git a/src/Pixel.Persistence.Respository/PrefabRepository.cs b/src/Pixel.Persistence.Respository/PrefabRepository.cs
index 80887e7d..daa38322 100644
--- a/src/Pixel.Persistence.Respository/PrefabRepository.cs
+++ b/src/Pixel.Persistence.Respository/PrefabRepository.cs
@@ -81,8 +81,7 @@ public async Task AddOrUpdatePrefabAsync(PrefabMetaData prefab, string fileName,
                             {"applicationId", prefab.ApplicationId},
                             {"version", prefab.Version},
                             {"type", prefab.Type},
-                            {"isActive", prefab.IsActive},
-                            {"isDeployed", prefab.IsDeployed}
+                            {"isActive", prefab.IsActive}
                         }
                     });
                     break;
@@ -176,7 +175,6 @@ public async Task<PrefabMetaDataCompact> GetPrefabMetadataForPrefabAsync(string
                     {
                         Version = file.Metadata["version"].AsString,
                         IsActive = file.Metadata["isActive"].AsBoolean,
-                        IsDeployed = file.Metadata["isDeployed"].AsBoolean,
                         LastUpdated = file.UploadDateTime
                     });
                 }
diff --git a/src/Pixel.Persistence.Respository/ProjectRepository.cs b/src/Pixel.Persistence.Respository/ProjectRepository.cs
index 45e8f90c..03a64454 100644
--- a/src/Pixel.Persistence.Respository/ProjectRepository.cs
+++ b/src/Pixel.Persistence.Respository/ProjectRepository.cs
@@ -79,8 +79,7 @@ public async Task AddOrUpdateProject(ProjectMetaData project, string fileName, b
                             {"projectId" , project.ProjectId},
                             {"version", project.Version},
                             {"type", project.Type},
-                            {"isActive", project.IsActive},
-                            {"isDeployed", project.IsDeployed}
+                            {"isActive", project.IsActive}
                         }
                     });
                     break;
@@ -176,7 +175,6 @@ public async IAsyncEnumerable<ProjectMetaData> GetProjectMetadataAsync(string pr
                         Version = file.Metadata["version"].AsString,
                         Type = file.Metadata["type"].AsString,
                         IsActive = file.Metadata["isActive"].AsBoolean,
-                        IsDeployed = file.Metadata["isDeployed"].AsBoolean,
                         LastUpdated = file.UploadDateTime
                     };
 
diff --git a/src/Pixel.Persistence.Services.Client/PrefabRepositoryClient.cs b/src/Pixel.Persistence.Services.Client/PrefabRepositoryClient.cs
index d1a9f2a0..3a483ec6 100644
--- a/src/Pixel.Persistence.Services.Client/PrefabRepositoryClient.cs
+++ b/src/Pixel.Persistence.Services.Client/PrefabRepositoryClient.cs
@@ -97,8 +97,7 @@ public async Task AddOrUpdatePrefabDataFilesAsync(PrefabProject prefabProject, V
                 ApplicationId = prefabProject.ApplicationId,
                 Type = "PrefabDataFiles",
                 Version = version.ToString(),
-                IsActive = version.IsActive,
-                IsDeployed = version.IsDeployed
+                IsActive = version.IsActive
             };
             restRequest.AddParameter(nameof(PrefabMetaData), serializer.Serialize<PrefabMetaData>(prefabMetaData), ParameterType.RequestBody);
             restRequest.AddFile("file", zippedDataFile);
diff --git a/src/Pixel.Persistence.Services.Client/ProjectRepositoryClient.cs b/src/Pixel.Persistence.Services.Client/ProjectRepositoryClient.cs
index b18562fe..3aaa02d2 100644
--- a/src/Pixel.Persistence.Services.Client/ProjectRepositoryClient.cs
+++ b/src/Pixel.Persistence.Services.Client/ProjectRepositoryClient.cs
@@ -95,8 +95,7 @@ public async Task AddOrUpdateProjectDataFiles(AutomationProject automationProjec
                 ProjectId = automationProject.ProjectId,
                 Type = "ProjectDataFiles",
                 Version = version.ToString(),
-                IsActive = version.IsActive,
-                IsDeployed = version.IsDeployed
+                IsActive = version.IsActive
             };
             restRequest.AddParameter(nameof(ProjectMetaData), serializer.Serialize<ProjectMetaData>(projectMetaData), ParameterType.RequestBody);
             restRequest.AddFile("file", zippedDataFile);
diff --git a/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/AutomationProjectFixture.cs b/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/AutomationProjectFixture.cs
index 23f9e53a..67a65e8d 100644
--- a/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/AutomationProjectFixture.cs
+++ b/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/AutomationProjectFixture.cs
@@ -14,24 +14,24 @@ public void ValidateThatAutomationProjectCanBeInitialized()
             Assert.IsEmpty(automationProject.Name);
             Assert.IsNotNull(automationProject.AvailableVersions);
             Assert.IsTrue(!automationProject.AvailableVersions.Any());
-            Assert.IsNotNull(automationProject.DeployedVersions);
-            Assert.IsTrue(!automationProject.DeployedVersions.Any());
-            Assert.IsNull(automationProject.ActiveVersion);          
+            Assert.IsNotNull(automationProject.PublishedVersions);
+            Assert.IsTrue(!automationProject.PublishedVersions.Any());
+            Assert.IsNull(automationProject.LatestActiveVersion);          
         }
 
         [Test]
         public void ValidateThatNewVersionCanBeAddedToAutomationProject()
         {
             var automationProject = new AutomationProject();
-            var deployedVersion = new ProjectVersion(new System.Version(1, 0)) { IsDeployed = true };
+            var deployedVersion = new ProjectVersion(new System.Version(1, 0)) { IsActive = false };
             var activeVersion = new ProjectVersion(new System.Version(1, 0)) { IsActive = true };
             automationProject.AvailableVersions.Add(deployedVersion);
             automationProject.AvailableVersions.Add(activeVersion);
 
             Assert.AreEqual(2, automationProject.AvailableVersions.Count());
-            Assert.AreEqual(1, automationProject.DeployedVersions.Count());
-            Assert.AreEqual(deployedVersion, automationProject.DeployedVersions.First());
-            Assert.AreEqual(activeVersion, automationProject.ActiveVersion);
+            Assert.AreEqual(1, automationProject.PublishedVersions.Count());
+            Assert.AreEqual(deployedVersion, automationProject.PublishedVersions.First());
+            Assert.AreEqual(activeVersion, automationProject.LatestActiveVersion);
         }
     }
 }
diff --git a/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/PrefabDescriptionFixture.cs b/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/PrefabDescriptionFixture.cs
index 33f838f4..a4aa2c94 100644
--- a/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/PrefabDescriptionFixture.cs
+++ b/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/PrefabDescriptionFixture.cs
@@ -20,8 +20,8 @@ public void ValidateThatPrefabDescriptionCanBeInitialized()
             Assert.AreEqual(null, prefabProject.PrefabName);
             Assert.AreEqual(null, prefabProject.Namespace);
             Assert.NotNull(prefabProject.AvailableVersions);
-            Assert.NotNull(prefabProject.DeployedVersions);
-            Assert.IsNull(prefabProject.ActiveVersion);
+            Assert.NotNull(prefabProject.PublishedVersions);
+            Assert.IsNull(prefabProject.LatestActiveVersion);
             Assert.AreEqual(null, prefabProject.Description);
             Assert.AreEqual("Default", prefabProject.GroupName);
 
@@ -30,7 +30,7 @@ public void ValidateThatPrefabDescriptionCanBeInitialized()
             prefabProject.PrefabId = "PrefabId";
             prefabProject.PrefabName = "PrefabName";
             prefabProject.Namespace = $"{Constants.PrefabNameSpacePrefix}.PrefabName";
-            prefabProject.AvailableVersions.Add(new PrefabVersion() { IsDeployed = true, Version = new Version(1, 0) });
+            prefabProject.AvailableVersions.Add(new PrefabVersion() { IsActive = false, Version = new Version(1, 0) });
             prefabProject.AvailableVersions.Add(new PrefabVersion() { IsActive = true, Version = new Version(2, 0) });
             prefabProject.Description = "Description";
             prefabProject.GroupName = "GroupName";
@@ -41,8 +41,8 @@ public void ValidateThatPrefabDescriptionCanBeInitialized()
             Assert.AreEqual("PrefabName", prefabProject.PrefabName);
             Assert.AreEqual($"{Constants.PrefabNameSpacePrefix}.PrefabName", prefabProject.Namespace);
             Assert.AreEqual(2, prefabProject.AvailableVersions.Count());
-            Assert.AreEqual(1, prefabProject.DeployedVersions.Count());
-            Assert.NotNull(prefabProject.ActiveVersion);
+            Assert.AreEqual(1, prefabProject.PublishedVersions.Count());
+            Assert.NotNull(prefabProject.LatestActiveVersion);
             Assert.AreEqual("Description", prefabProject.Description);
             Assert.AreEqual("GroupName", prefabProject.GroupName);
         }
diff --git a/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/VersionInfoFixture.cs b/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/VersionInfoFixture.cs
index bbb4c6e9..2bdcb8bb 100644
--- a/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/VersionInfoFixture.cs
+++ b/src/Unit.Tests/Pixel.Automation.Core.Tests/Models/VersionInfoFixture.cs
@@ -12,7 +12,7 @@ public void ValidatethatProjectVersionCanBeInitializedFromVersionString()
             var projectVersion = new ProjectVersion("1.0.0.0");
 
             Assert.IsTrue(projectVersion.IsActive);
-            Assert.IsFalse(projectVersion.IsDeployed);
+            Assert.IsFalse(projectVersion.IsPublished);
             Assert.IsTrue(string.IsNullOrEmpty(projectVersion.DataModelAssembly));
             Assert.IsTrue(string.IsNullOrEmpty(projectVersion.Description));
             Assert.AreEqual("1.0.0.0", projectVersion.ToString());
@@ -23,14 +23,13 @@ public void ValidatethatProjectVersionCanBeInitializedFromVersion()
         {
             var projectVersion = new ProjectVersion(new Version(1, 0, 0, 0))
             {
-                IsActive = false,
-                IsDeployed = true,
+                IsActive = false,               
                 DataModelAssembly = "Assembly",
                 Description = "Description"
             };
 
             Assert.IsFalse(projectVersion.IsActive);
-            Assert.IsTrue(projectVersion.IsDeployed);
+            Assert.IsTrue(projectVersion.IsPublished);
             Assert.AreEqual("Assembly", projectVersion.DataModelAssembly);
             Assert.AreEqual("Description", projectVersion.Description);
             Assert.AreEqual("1.0.0.0", projectVersion.ToString());
@@ -45,7 +44,7 @@ public void ValidatethatPrefabVersionCanBeInitializedFromVersionString()
             var prefabVersion = new PrefabVersion("1.0.0.0");
 
             Assert.IsTrue(prefabVersion.IsActive);
-            Assert.IsFalse(prefabVersion.IsDeployed);
+            Assert.IsFalse(prefabVersion.IsPublished);
             Assert.IsTrue(string.IsNullOrEmpty(prefabVersion.DataModelAssembly));
             Assert.IsTrue(string.IsNullOrEmpty(prefabVersion.Description));
             Assert.AreEqual("1.0.0.0", prefabVersion.ToString());
@@ -56,14 +55,13 @@ public void ValidatethatProjectVersionCanBeInitializedFromVersion()
         {
             var prefabVersion = new PrefabVersion(new Version(1, 0, 0, 0))
             {
-                IsActive = false,
-                IsDeployed = true,
+                IsActive = false,              
                 DataModelAssembly = "Assembly",
                 Description = "Description"
             };
 
             Assert.IsFalse(prefabVersion.IsActive);
-            Assert.IsTrue(prefabVersion.IsDeployed);
+            Assert.IsTrue(prefabVersion.IsPublished);
             Assert.AreEqual("Assembly", prefabVersion.DataModelAssembly);
             Assert.AreEqual("Description", prefabVersion.Description);
             Assert.AreEqual("1.0.0.0", prefabVersion.ToString());