diff --git a/src/Umbraco.Core/ApplicationContext.cs b/src/Umbraco.Core/ApplicationContext.cs
index 79e4a72756..f1bb929a94 100644
--- a/src/Umbraco.Core/ApplicationContext.cs
+++ b/src/Umbraco.Core/ApplicationContext.cs
@@ -165,6 +165,9 @@ namespace Umbraco.Core
         /// </remarks>
         internal string OriginalRequestUrl { get; set; }
 
+        /// <summary>
+        /// Checks if the version configured matches the assembly version
+        /// </summary>
 		private bool Configured
 		{
 			get
diff --git a/src/Umbraco.Core/DatabaseContext.cs b/src/Umbraco.Core/DatabaseContext.cs
index 5e0c1cd29f..435470a493 100644
--- a/src/Umbraco.Core/DatabaseContext.cs
+++ b/src/Umbraco.Core/DatabaseContext.cs
@@ -615,5 +615,34 @@ namespace Umbraco.Core
             public bool Success { get; set; }
             public string Percentage { get; set; }
         }
+
+        internal bool IsConnectionStringConfigured(ConnectionStringSettings databaseSettings)
+        {
+            var dbIsSqlCe = false;
+            if (databaseSettings != null && databaseSettings.ProviderName != null)
+                dbIsSqlCe = databaseSettings.ProviderName == "System.Data.SqlServerCe.4.0";
+            var sqlCeDatabaseExists = false;
+            if (dbIsSqlCe)
+            {
+                var parts = databaseSettings.ConnectionString.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
+                var dataSourcePart = parts.FirstOrDefault(x => x.InvariantStartsWith("Data Source="));
+                if (dataSourcePart != null)
+                {
+                    var datasource = dataSourcePart.Replace("|DataDirectory|", AppDomain.CurrentDomain.GetData("DataDirectory").ToString());
+                    var filePath = datasource.Replace("Data Source=", string.Empty);
+                    sqlCeDatabaseExists = File.Exists(filePath);                    
+                }
+            }
+
+            // Either the connection details are not fully specified or it's a SQL CE database that doesn't exist yet
+            if (databaseSettings == null
+                || string.IsNullOrWhiteSpace(databaseSettings.ConnectionString) || string.IsNullOrWhiteSpace(databaseSettings.ProviderName)
+                || (dbIsSqlCe && sqlCeDatabaseExists == false))
+            {
+                return false;
+            }
+
+            return true;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Tests/Install/InstallHelperTests.cs b/src/Umbraco.Tests/Install/InstallHelperTests.cs
index ecce6d6b85..4c68a3df4a 100644
--- a/src/Umbraco.Tests/Install/InstallHelperTests.cs
+++ b/src/Umbraco.Tests/Install/InstallHelperTests.cs
@@ -10,6 +10,7 @@ using Newtonsoft.Json.Linq;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence;
 using Umbraco.Web;
 using Umbraco.Web.Install;
 using Umbraco.Web.Install.Controllers;
@@ -78,6 +79,7 @@ namespace Umbraco.Tests.Install
         {
             var appCtx = new ApplicationContext(CacheHelper.CreateDisabledCacheHelper());
             ApplicationContext.EnsureContext(appCtx, true);
+            appCtx.DatabaseContext = new DatabaseContext(Mock.Of<IDatabaseFactory>());
 
             var umbCtx = UmbracoContext.EnsureContext(
                 new Mock<HttpContextBase>().Object,
@@ -88,8 +90,8 @@ namespace Umbraco.Tests.Install
 
             var steps = helper.GetSteps().ToArray();
 
-            //for upgrades 5, don't require execution (the db context is not configured so the upgrade report will not execute either)
-            Assert.AreEqual(5, steps.Count(x => x.RequiresExecution() == false));
+            //for upgrades 4, don't require execution 
+            Assert.AreEqual(4, steps.Count(x => x.RequiresExecution() == false));
 
         }
 
diff --git a/src/Umbraco.Web.UI.Client/src/installer/steps/upgrade.html b/src/Umbraco.Web.UI.Client/src/installer/steps/upgrade.html
new file mode 100644
index 0000000000..8cbff93233
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/installer/steps/upgrade.html
@@ -0,0 +1,3 @@
+<div>
+    Start upgrade!
+</div>
\ No newline at end of file
diff --git a/src/Umbraco.Web.UI.Client/src/installer/steps/version7upgradereport.html b/src/Umbraco.Web.UI.Client/src/installer/steps/version7upgradereport.html
new file mode 100644
index 0000000000..651f7fd30b
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/installer/steps/version7upgradereport.html
@@ -0,0 +1,3 @@
+<div>
+    Upgrade report :)
+</div>
\ No newline at end of file
diff --git a/src/Umbraco.Web.UI/config/ClientDependency.config b/src/Umbraco.Web.UI/config/ClientDependency.config
index 1e4c529156..02486b0ff6 100644
--- a/src/Umbraco.Web.UI/config/ClientDependency.config
+++ b/src/Umbraco.Web.UI/config/ClientDependency.config
@@ -10,7 +10,7 @@ NOTES:
 * Compression/Combination/Minification is not enabled unless debug="false" is specified on the 'compiliation' element in the web.config
 * A new version will invalidate both client and server cache and create new persisted files
 --> 
-<clientDependency version="1722535864" fileDependencyExtensions=".js,.css" loggerType="Umbraco.Web.UI.CdfLogger, umbraco">
+<clientDependency version="1999622582" fileDependencyExtensions=".js,.css" loggerType="Umbraco.Web.UI.CdfLogger, umbraco">
 
   <!-- 
     This section is used for Web Forms only, the enableCompositeFiles="true" is optional and by default is set to true.
diff --git a/src/Umbraco.Web/Install/Controllers/InstallApiController.cs b/src/Umbraco.Web/Install/Controllers/InstallApiController.cs
index efab741b51..015a72eec7 100644
--- a/src/Umbraco.Web/Install/Controllers/InstallApiController.cs
+++ b/src/Umbraco.Web/Install/Controllers/InstallApiController.cs
@@ -58,18 +58,20 @@ namespace Umbraco.Web.Install.Controllers
         /// <returns></returns>
         public InstallSetup GetSetup()
         {
-            var setup = new InstallSetup()
-            {
-                Status = InstallHelper.GetStatus()
-            };
-
+            var setup = new InstallSetup();
+            
             //TODO: Check for user/site token
 
             var steps = new List<InstallSetupStep>();
 
-            steps.AddRange(InstallHelper.GetSteps().Where(x => x.RequiresExecution()));
+            var installSteps = InstallHelper.GetStepsForCurrentInstallType().ToArray();
+
+            //only get the steps that are targetting the current install type
+            steps.AddRange(installSteps);
             setup.Steps = steps;
 
+            InstallStatusTracker.Initialize(setup.InstallId, installSteps);
+
             return setup;
         }
 
@@ -113,9 +115,10 @@ namespace Umbraco.Web.Install.Controllers
             if (installModel == null) throw new ArgumentNullException("installModel");
 
             var status = InstallStatusTracker.GetStatus().ToArray();
+            //there won't be any statuses returned if the app pool has restarted so we need to re-read from file.
             if (status.Any() == false)
             {
-                status = InstallStatusTracker.Initialize(installModel.InstallId, InstallHelper.GetSteps()).ToArray();
+                status = InstallStatusTracker.InitializeFromFile(installModel.InstallId).ToArray();
             }
 
             foreach (var stepStatus in status)
@@ -123,7 +126,7 @@ namespace Umbraco.Web.Install.Controllers
                 //if it is not complete, then we need to execute it
                 if (stepStatus.IsComplete == false)
                 {
-                    var step = InstallHelper.GetSteps().Single(x => x.Name == stepStatus.Name);
+                    var step = InstallHelper.GetAllSteps().Single(x => x.Name == stepStatus.Name);
 
                     JToken instruction = null;
                     if (step.HasUIElement)
diff --git a/src/Umbraco.Web/Install/InstallHelper.cs b/src/Umbraco.Web/Install/InstallHelper.cs
index 7964ac3edc..144bab203a 100644
--- a/src/Umbraco.Web/Install/InstallHelper.cs
+++ b/src/Umbraco.Web/Install/InstallHelper.cs
@@ -9,6 +9,7 @@ using System.Web.UI;
 
 using Umbraco.Core;
 using Umbraco.Core.Configuration;
+using Umbraco.Core.Persistence;
 using Umbraco.Web.Install.InstallSteps;
 using Umbraco.Web.Install.Models;
 
@@ -17,65 +18,70 @@ namespace Umbraco.Web.Install
     internal class InstallHelper
     {
         private readonly UmbracoContext _umbContext;
-        private readonly InstallStatusType _status;
+        private InstallationType? _installationType;
 
         internal InstallHelper(UmbracoContext umbContext)
-            : this(umbContext, GlobalSettings.ConfigurationStatus.IsNullOrWhiteSpace()
-                ? InstallStatusType.NewInstall
-                : InstallStatusType.Upgrade)
         {
+            _umbContext = umbContext;            
         }
 
-        internal InstallHelper(UmbracoContext umbContext, InstallStatusType status)
-        {
-            _umbContext = umbContext;
-            _status = status;
-        }
-
-        public InstallStatusType GetStatus()
-        {
-            return _status;
-        }
 
         /// <summary>
         /// Get the installer steps
         /// </summary>
         /// <returns></returns>
         /// <remarks>
-        /// The step order returned here is how they will appear on the front-end
+        /// The step order returned here is how they will appear on the front-end if they have views assigned
         /// </remarks>
-        public IEnumerable<InstallSetupStep> GetSteps()
+        public IEnumerable<InstallSetupStep> GetAllSteps()
         {
             return new List<InstallSetupStep>
-            {
+            {                
+                new UserStep(_umbContext.Application),
+                new Upgrade(),
                 new FilePermissionsStep(),
-                new UserStep(_umbContext.Application, _status),
-                new MajorVersion7UpgradeReport(_umbContext.Application, _status),
+                new MajorVersion7UpgradeReport(_umbContext.Application),
                 new DatabaseConfigureStep(_umbContext.Application),
                 new DatabaseInstallStep(_umbContext.Application),
-                new DatabaseUpgradeStep(_umbContext.Application, _status),
-                new StarterKitDownloadStep(_status),
-                new StarterKitInstallStep(_status, _umbContext.Application, _umbContext.HttpContext),
-                new StarterKitCleanupStep(_status),
+                new DatabaseUpgradeStep(_umbContext.Application),
+                new StarterKitDownloadStep(_umbContext.Application),
+                new StarterKitInstallStep(_umbContext.Application, _umbContext.HttpContext),
+                new StarterKitCleanupStep(_umbContext.Application),
                 new SetUmbracoVersionStep(_umbContext.Application, _umbContext.HttpContext),
             };
         }
-        
-        //public static bool IsNewInstall
-        //{
-        //    get
-        //    {
-        //        var databaseSettings = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName];
-        //        if (databaseSettings != null && (
-        //            databaseSettings.ConnectionString.Trim() == string.Empty
-        //            && databaseSettings.ProviderName.Trim() == string.Empty
-        //            && GlobalSettings.ConfigurationStatus == string.Empty))
-        //        {
-        //            return true;
-        //        }
 
-        //        return false;
-        //    }
-        //}
+        /// <summary>
+        /// Returns the steps that are used only for the current installation type
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerable<InstallSetupStep> GetStepsForCurrentInstallType()
+        {
+            return GetAllSteps().Where(x => x.InstallTypeTarget.HasFlag(GetInstallationType()));
+        }
+
+        public InstallationType GetInstallationType()
+        {
+            return _installationType ?? (_installationType = IsNewInstall ? InstallationType.NewInstall : InstallationType.Upgrade).Value;
+        }
+
+        /// <summary>
+        /// Checks if this is a brand new install meaning that there is no configured version and there is no configured database connection
+        /// </summary>
+        private bool IsNewInstall
+        {
+            get
+            {
+                var databaseSettings = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName];
+                if (GlobalSettings.ConfigurationStatus.IsNullOrWhiteSpace()
+                    && _umbContext.Application.DatabaseContext.IsConnectionStringConfigured(databaseSettings) == false)
+                {
+                    //no version or conn string configured, must be a brand new install
+                    return true;
+                }
+
+                return false;
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Install/InstallStatusTracker.cs b/src/Umbraco.Web/Install/InstallStatusTracker.cs
index 77aee610b4..22f92955dc 100644
--- a/src/Umbraco.Web/Install/InstallStatusTracker.cs
+++ b/src/Umbraco.Web/Install/InstallStatusTracker.cs
@@ -33,6 +33,11 @@ namespace Umbraco.Web.Install
         public static void Reset()
         {
             _steps = new ConcurrentHashSet<InstallTrackingItem>();
+            ClearFiles();
+        }
+
+        public static void ClearFiles()
+        {
             var files = Directory.GetFiles(IOHelper.MapPath("~/App_Data/TEMP/Install/"));
             foreach (var f in files)
             {
@@ -40,6 +45,26 @@ namespace Umbraco.Web.Install
             }
         }
 
+        public static IEnumerable<InstallTrackingItem> InitializeFromFile(Guid installId)
+        {
+            //check if we have our persisted file and read it
+            var file = GetFile(installId);
+            if (File.Exists(file))
+            {
+                var deserialized = JsonConvert.DeserializeObject<IEnumerable<InstallTrackingItem>>(
+                    File.ReadAllText(file));
+                foreach (var item in deserialized)
+                {
+                    _steps.Add(item);
+                }
+            }
+            else
+            {
+                throw new InvalidOperationException("Cannot initialize from file, the installation file with id " + installId + " does not exist");
+            }
+            return new List<InstallTrackingItem>(_steps);
+        }
+
         public static IEnumerable<InstallTrackingItem> Initialize(Guid installId, IEnumerable<InstallSetupStep> steps)
         {
             //if there are no steps in memory
@@ -58,10 +83,12 @@ namespace Umbraco.Web.Install
                 }
                 else
                 {
+                    ClearFiles();
+
                     //otherwise just create the steps in memory (brand new install)
                     foreach (var step in steps.OrderBy(x => x.ServerOrder))
                     {
-                        _steps.Add(new InstallTrackingItem(step.Name, step.ServerOrder)); 
+                        _steps.Add(new InstallTrackingItem(step.Name, step.ServerOrder));
                     }
                     //save the file
                     var serialized = JsonConvert.SerializeObject(new List<InstallTrackingItem>(_steps));
@@ -69,6 +96,20 @@ namespace Umbraco.Web.Install
                     File.WriteAllText(file, serialized);
                 }
             }
+            else
+            {
+                //ensure that the file exists with the current install id
+                var file = GetFile(installId);
+                if (File.Exists(file) == false)
+                {
+                    ClearFiles();
+
+                    //save the correct file
+                    var serialized = JsonConvert.SerializeObject(new List<InstallTrackingItem>(_steps));
+                    Directory.CreateDirectory(Path.GetDirectoryName(file));
+                    File.WriteAllText(file, serialized);
+                }
+            }
 
             return new List<InstallTrackingItem>(_steps);
         }
diff --git a/src/Umbraco.Web/Install/InstallSteps/DatabaseConfigureStep.cs b/src/Umbraco.Web/Install/InstallSteps/DatabaseConfigureStep.cs
index 85ff8520e3..fdfc954d53 100644
--- a/src/Umbraco.Web/Install/InstallSteps/DatabaseConfigureStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/DatabaseConfigureStep.cs
@@ -13,7 +13,8 @@ using Umbraco.Web.Install.Models;
 
 namespace Umbraco.Web.Install.InstallSteps
 {
-    [InstallSetupStep("DatabaseConfigure", "database", 10, "Configuring your database connection")]
+    [InstallSetupStep(InstallationType.NewInstall,
+        "DatabaseConfigure", "database", 10, "Configuring your database connection")]
     internal class DatabaseConfigureStep : InstallSetupStep<DatabaseModel>
     {
         private readonly ApplicationContext _applicationContext;
@@ -95,8 +96,7 @@ namespace Umbraco.Web.Install.InstallSteps
 
         public override bool RequiresExecution()
         {
-            //TODO: We need to determine if we should run this based on whether the conn string is configured already
-            return true;
+            return ShouldDisplayView();
         }
 
         private bool ShouldDisplayView()
@@ -104,40 +104,23 @@ namespace Umbraco.Web.Install.InstallSteps
             //If the connection string is already present in web.config we don't need to show the settings page and we jump to installing/upgrading.
             var databaseSettings = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName];
 
-            var dbIsSqlCe = false;
-            if (databaseSettings != null && databaseSettings.ProviderName != null)
-                dbIsSqlCe = databaseSettings.ProviderName == "System.Data.SqlServerCe.4.0";
-            var sqlCeDatabaseExists = false;
-            if (dbIsSqlCe)
+            if (_applicationContext.DatabaseContext.IsConnectionStringConfigured(databaseSettings))
             {
-                var datasource = databaseSettings.ConnectionString.Replace("|DataDirectory|", AppDomain.CurrentDomain.GetData("DataDirectory").ToString());
-                var filePath = datasource.Replace("Data Source=", string.Empty);
-                sqlCeDatabaseExists = File.Exists(filePath);
+                try
+                {
+                    //Since a connection string was present we verify the db can connect and query
+                    var result = _applicationContext.DatabaseContext.ValidateDatabaseSchema();
+                    result.DetermineInstalledVersion();
+                    return false;
+                }
+                catch (Exception)
+                {
+                    //something went wrong, could not connect so probably need to reconfigure
+                    return true;
+                }
             }
 
-            // Either the connection details are not fully specified or it's a SQL CE database that doesn't exist yet
-            if (databaseSettings == null
-                || string.IsNullOrWhiteSpace(databaseSettings.ConnectionString) || string.IsNullOrWhiteSpace(databaseSettings.ProviderName)
-                || (dbIsSqlCe && sqlCeDatabaseExists == false))
-            {
-                return true;
-            }
-            else
-            {
-                //Since a connection string was present we verify whether this is an upgrade or an empty db
-                var result = ApplicationContext.Current.DatabaseContext.ValidateDatabaseSchema();
-                var determinedVersion = result.DetermineInstalledVersion();
-                if (determinedVersion.Equals(new Version(0, 0, 0)))
-                {
-                    //Fresh install
-                    return false;
-                }
-                else
-                {
-                    //Upgrade
-                    return false;
-                }
-            }
+            return true;
         }
     }
 }
diff --git a/src/Umbraco.Web/Install/InstallSteps/DatabaseInstallStep.cs b/src/Umbraco.Web/Install/InstallSteps/DatabaseInstallStep.cs
index 927804475a..ea3054f3ba 100644
--- a/src/Umbraco.Web/Install/InstallSteps/DatabaseInstallStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/DatabaseInstallStep.cs
@@ -8,7 +8,8 @@ using Umbraco.Web.Install.Models;
 
 namespace Umbraco.Web.Install.InstallSteps
 {
-    [InstallSetupStep("DatabaseInstall", 11, "Installing database tables and default system data")]
+    [InstallSetupStep(InstallationType.NewInstall | InstallationType.Upgrade,
+        "DatabaseInstall", 11, "Installing database tables and default system data")]
     internal class DatabaseInstallStep : InstallSetupStep<object>
     {
         private readonly ApplicationContext _applicationContext;
@@ -24,12 +25,18 @@ namespace Umbraco.Web.Install.InstallSteps
             if (result.RequiresUpgrade == false)
             {
                 HandleConnectionStrings();
+                return null;
+            }
+            else
+            {
+                //upgrade is required so set the flag for the next step
+
                 return new InstallSetupResult(new Dictionary<string, object>
                 {
                     {"upgrade", true}
                 });
-            }   
-            return null;
+            }
+            
         }
 
         internal static void HandleConnectionStrings()
diff --git a/src/Umbraco.Web/Install/InstallSteps/DatabaseUpgradeStep.cs b/src/Umbraco.Web/Install/InstallSteps/DatabaseUpgradeStep.cs
index 4eeb9a4c62..9db963f29d 100644
--- a/src/Umbraco.Web/Install/InstallSteps/DatabaseUpgradeStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/DatabaseUpgradeStep.cs
@@ -1,28 +1,27 @@
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Linq;
 using Umbraco.Core;
+using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Web.Install.Models;
 
 namespace Umbraco.Web.Install.InstallSteps
 {
-    [InstallSetupStep("DatabaseUpgrade", 12, "Upgrading your database to the latest version")]
+    [InstallSetupStep(InstallationType.Upgrade,
+        "DatabaseUpgrade", 12, "Upgrading your database to the latest version")]
     internal class DatabaseUpgradeStep : InstallSetupStep<object>
     {
         private readonly ApplicationContext _applicationContext;
-        private readonly InstallStatusType _status;
-
-        public DatabaseUpgradeStep(ApplicationContext applicationContext, InstallStatusType status)
+        
+        public DatabaseUpgradeStep(ApplicationContext applicationContext)
         {
             _applicationContext = applicationContext;
-            _status = status;
         }
 
         public override InstallSetupResult Execute(object model)
         {
-            if (_status == InstallStatusType.NewInstall) return null;
-
             var installSteps = InstallStatusTracker.GetStatus().ToArray();
             //this step relies on the preious one completed - because it has stored some information we need
             if (installSteps.Any(x => x.Name == "DatabaseConfigure") == false)
@@ -46,7 +45,40 @@ namespace Umbraco.Web.Install.InstallSteps
 
         public override bool RequiresExecution()
         {
-            return _status != InstallStatusType.NewInstall;
+            //if it's properly configured (i.e. the versions match) then no upgrade necessary
+            if (_applicationContext.IsConfigured)
+            {
+                return false;
+            }
+            
+            var databaseSettings = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName];
+
+            if (_applicationContext.DatabaseContext.IsConnectionStringConfigured(databaseSettings))
+            {
+                try
+                {
+                    //Since a connection string was present we verify whether this is an upgrade or an empty db
+                    var result = _applicationContext.DatabaseContext.ValidateDatabaseSchema();
+
+                    var determinedVersion = result.DetermineInstalledVersion();
+                    if (determinedVersion.Equals(new Version(0, 0, 0)))
+                    {
+                        //Fresh install
+                        return false;
+                    }
+
+                    //Upgrade
+                    return true;
+                }
+                catch (Exception)
+                {
+                    //something went wrong, could not connect so probably need to reconfigure
+                    return false;
+                }
+            }
+
+            //no connection string configured, probably a fresh install
+            return false;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Install/InstallSteps/FilePermissionsStep.cs b/src/Umbraco.Web/Install/InstallSteps/FilePermissionsStep.cs
index 02a5330afe..3495b70eaf 100644
--- a/src/Umbraco.Web/Install/InstallSteps/FilePermissionsStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/FilePermissionsStep.cs
@@ -8,7 +8,8 @@ using Umbraco.Web.Install.Models;
 
 namespace Umbraco.Web.Install.InstallSteps
 {
-    [InstallSetupStep("Permissions", 0, "Ensuring your file permissions are set correctly")]
+    [InstallSetupStep(InstallationType.NewInstall | InstallationType.Upgrade,
+        "Permissions", 0, "Ensuring your file permissions are set correctly")]
     internal class FilePermissionsStep : InstallSetupStep<object>
     {
         public override InstallSetupResult Execute(object model)
diff --git a/src/Umbraco.Web/Install/InstallSteps/MajorVersion7UpgradeReport.cs b/src/Umbraco.Web/Install/InstallSteps/MajorVersion7UpgradeReport.cs
index f8b5bda68a..a64a9f4b51 100644
--- a/src/Umbraco.Web/Install/InstallSteps/MajorVersion7UpgradeReport.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/MajorVersion7UpgradeReport.cs
@@ -9,24 +9,19 @@ using Umbraco.Web.Install.Models;
 
 namespace Umbraco.Web.Install.InstallSteps
 {
-    [InstallSetupStep("MajorVersion7UpgradeReport", 1, "Checking for compatibility issues with upgrade")]
+    [InstallSetupStep(InstallationType.Upgrade,
+        "MajorVersion7UpgradeReport", 1, "Checking for compatibility issues with upgrade")]
     internal class MajorVersion7UpgradeReport : InstallSetupStep<object>
     {
         private readonly ApplicationContext _applicationContext;
-        private readonly InstallStatusType _status;
 
-        public MajorVersion7UpgradeReport(ApplicationContext applicationContext, InstallStatusType status)
+        public MajorVersion7UpgradeReport(ApplicationContext applicationContext)
         {
             _applicationContext = applicationContext;
-            _status = status;
         }
 
         public override InstallSetupResult Execute(object model)
         {
-            if (_status == InstallStatusType.NewInstall)
-            {
-                return null;
-            }
             //we cannot run this step if the db is not configured.
             if (_applicationContext.DatabaseContext.IsDatabaseConfigured == false)
             {
@@ -35,10 +30,11 @@ namespace Umbraco.Web.Install.InstallSteps
 
             return new InstallSetupResult("version7upgradereport", CreateReport());
         }
-        
+
         public override bool RequiresExecution()
         {
-            if (_status == InstallStatusType.NewInstall)
+            //if it's configured, then no need to run
+            if (_applicationContext.IsConfigured)
             {
                 return false;
             }
diff --git a/src/Umbraco.Web/Install/InstallSteps/SetUmbracoVersionStep.cs b/src/Umbraco.Web/Install/InstallSteps/SetUmbracoVersionStep.cs
index 35b2c4e884..3aeda70570 100644
--- a/src/Umbraco.Web/Install/InstallSteps/SetUmbracoVersionStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/SetUmbracoVersionStep.cs
@@ -10,7 +10,8 @@ using GlobalSettings = umbraco.GlobalSettings;
 
 namespace Umbraco.Web.Install.InstallSteps
 {
-    [InstallSetupStep("UmbracoVersion", 50, "Wrapping up the system configuration")]
+    [InstallSetupStep(InstallationType.NewInstall | InstallationType.Upgrade,
+        "UmbracoVersion", 50, "Wrapping up the system configuration")]
     internal class SetUmbracoVersionStep : InstallSetupStep<object>
     {
         private readonly ApplicationContext _applicationContext;
diff --git a/src/Umbraco.Web/Install/InstallSteps/StarterKitCleanupStep.cs b/src/Umbraco.Web/Install/InstallSteps/StarterKitCleanupStep.cs
index 2c13c9527b..72b57c0ef0 100644
--- a/src/Umbraco.Web/Install/InstallSteps/StarterKitCleanupStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/StarterKitCleanupStep.cs
@@ -3,30 +3,26 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Web;
 using umbraco;
+using umbraco.cms.businesslogic.packager;
+using Umbraco.Core;
 using Umbraco.Web.Install.Models;
 
 namespace Umbraco.Web.Install.InstallSteps
 {
-    [InstallSetupStep("StarterKitCleanup", 32, "Cleaning up temporary files")]
+    [InstallSetupStep(InstallationType.NewInstall, 
+        "StarterKitCleanup", 32, "Cleaning up temporary files")]
     internal class StarterKitCleanupStep : InstallSetupStep<object>
     {
-        private readonly InstallStatusType _status;
+        private readonly ApplicationContext _applicationContext;
 
-        public StarterKitCleanupStep(InstallStatusType status)
+        public StarterKitCleanupStep(ApplicationContext applicationContext)
         {
-            _status = status;
+            _applicationContext = applicationContext;
         }
 
         public override InstallSetupResult Execute(object model)
         {
-            if (_status != InstallStatusType.NewInstall) return null;
-
             var installSteps = InstallStatusTracker.GetStatus().ToArray();
-            //this step relies on the preious one completed - because it has stored some information we need
-            if (installSteps.Any(x => x.Name == "StarterKitDownload") == false)
-            {
-                throw new InvalidOperationException("Could not find previous step: StarterKitDownload of the installation, package install cannot continue");
-            }
             var previousStep = installSteps.Single(x => x.Name == "StarterKitDownload");
             var manifestId = Convert.ToInt32(previousStep.AdditionalData["manifestId"]);
             var packageFile = (string)previousStep.AdditionalData["packageFile"];
@@ -39,7 +35,7 @@ namespace Umbraco.Web.Install.InstallSteps
         private void CleanupInstallation(int manifestId, string packageFile)
         {
             packageFile = HttpUtility.UrlDecode(packageFile);
-            var installer = new global::umbraco.cms.businesslogic.packager.Installer();
+            var installer = new Installer();
             installer.LoadConfig(packageFile);
             installer.InstallCleanUp(manifestId, packageFile);
 
@@ -48,7 +44,20 @@ namespace Umbraco.Web.Install.InstallSteps
 
         public override bool RequiresExecution()
         {
-            return _status == InstallStatusType.NewInstall;
+            if (InstalledPackage.GetAllInstalledPackages().Count > 0)
+                return false;
+
+            if (_applicationContext.Services.ContentService.GetRootContent().Any())
+                return false;
+
+            var installSteps = InstallStatusTracker.GetStatus().ToArray();
+            //this step relies on the preious one completed - because it has stored some information we need
+            if (installSteps.Any(x => x.Name == "StarterKitDownload") == false)
+            {
+                return false;
+            }
+
+            return true;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Install/InstallSteps/StarterKitDownloadStep.cs b/src/Umbraco.Web/Install/InstallSteps/StarterKitDownloadStep.cs
index d6dcdaa441..ed9d7ce52b 100644
--- a/src/Umbraco.Web/Install/InstallSteps/StarterKitDownloadStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/StarterKitDownloadStep.cs
@@ -1,26 +1,28 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Web;
+using umbraco.cms.businesslogic.packager;
 using Umbraco.Core;
 using Umbraco.Web.Install.Models;
 
 namespace Umbraco.Web.Install.InstallSteps
 {
-    [InstallSetupStep("StarterKitDownload", "starterKit", 30, "Downloading a starter website from our.umbraco.org, hold tight, this could take a little while")]
+    [InstallSetupStep(InstallationType.NewInstall,
+        "StarterKitDownload", "starterKit", 30, "Downloading a starter website from our.umbraco.org, hold tight, this could take a little while")]
     internal class StarterKitDownloadStep : InstallSetupStep<Guid>
     {
-        private readonly InstallStatusType _status;
+        private readonly ApplicationContext _applicationContext;
 
-        public StarterKitDownloadStep(InstallStatusType status)
+        public StarterKitDownloadStep(ApplicationContext applicationContext)
         {
-            _status = status;
+            _applicationContext = applicationContext;
         }
 
         private const string RepoGuid = "65194810-1f85-11dd-bd0b-0800200c9a66";
 
         public override InstallSetupResult Execute(Guid starterKitId)
         {
-            if (_status != InstallStatusType.NewInstall) return null;
 
             var result = DownloadPackageFiles(starterKitId);
 
@@ -42,7 +44,7 @@ namespace Umbraco.Web.Install.InstallSteps
             {
                 throw new InvalidOperationException("Cannot connect to repository");                
             }
-            var installer = new global::umbraco.cms.businesslogic.packager.Installer();
+            var installer = new Installer();
 
             var tempFile = installer.Import(repo.fetch(kitGuid.ToString()));
             installer.LoadConfig(tempFile);
@@ -56,7 +58,7 @@ namespace Umbraco.Web.Install.InstallSteps
         private void InstallPackageFiles(int manifestId, string packageFile)
         {
             packageFile = HttpUtility.UrlDecode(packageFile);
-            var installer = new global::umbraco.cms.businesslogic.packager.Installer();
+            var installer = new Installer();
             installer.LoadConfig(packageFile);
             installer.InstallFiles(manifestId, packageFile);
             
@@ -64,7 +66,13 @@ namespace Umbraco.Web.Install.InstallSteps
 
         public override bool RequiresExecution()
         {
-            return _status == InstallStatusType.NewInstall;
+            if (InstalledPackage.GetAllInstalledPackages().Count > 0)
+                return false;
+
+            if (_applicationContext.Services.ContentService.GetRootContent().Any())
+                return false;
+
+            return true;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Install/InstallSteps/StarterKitInstallStep.cs b/src/Umbraco.Web/Install/InstallSteps/StarterKitInstallStep.cs
index e75f640439..0d140d8462 100644
--- a/src/Umbraco.Web/Install/InstallSteps/StarterKitInstallStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/StarterKitInstallStep.cs
@@ -2,21 +2,21 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
+using umbraco.cms.businesslogic.packager;
 using Umbraco.Core;
 using Umbraco.Web.Install.Models;
 
 namespace Umbraco.Web.Install.InstallSteps
 {
-    [InstallSetupStep("StarterKitInstall", 31, "Installing a starter website to help you get off to a great start")]
+    [InstallSetupStep(InstallationType.NewInstall,
+        "StarterKitInstall", 31, "Installing a starter website to help you get off to a great start")]
     internal class StarterKitInstallStep : InstallSetupStep<object>
     {
-        private readonly InstallStatusType _status;
         private readonly ApplicationContext _applicationContext;
         private readonly HttpContextBase _httContext;
 
-        public StarterKitInstallStep(InstallStatusType status, ApplicationContext applicationContext, HttpContextBase httContext)
+        public StarterKitInstallStep(ApplicationContext applicationContext, HttpContextBase httContext)
         {
-            _status = status;
             _applicationContext = applicationContext;
             _httContext = httContext;
         }
@@ -24,14 +24,7 @@ namespace Umbraco.Web.Install.InstallSteps
 
         public override InstallSetupResult Execute(object model)
         {
-            if (_status != InstallStatusType.NewInstall) return null;
-
-            var installSteps = InstallStatusTracker.GetStatus().ToArray();
-            //this step relies on the preious one completed - because it has stored some information we need
-            if (installSteps.Any(x => x.Name == "StarterKitDownload") == false)            
-            {
-                throw new InvalidOperationException("Could not find previous step: StarterKitDownload of the installation, package install cannot continue");
-            }
+            var installSteps = InstallStatusTracker.GetStatus().ToArray();            
             var previousStep = installSteps.Single(x => x.Name == "StarterKitDownload");
             var manifestId = Convert.ToInt32(previousStep.AdditionalData["manifestId"]);
             var packageFile = (string)previousStep.AdditionalData["packageFile"];
@@ -46,14 +39,27 @@ namespace Umbraco.Web.Install.InstallSteps
         private void InstallBusinessLogic(int manifestId, string packageFile)
         {
             packageFile = HttpUtility.UrlDecode(packageFile);
-            var installer = new global::umbraco.cms.businesslogic.packager.Installer();
+            var installer = new Installer();
             installer.LoadConfig(packageFile);
             installer.InstallBusinessLogic(manifestId, packageFile);            
         }
 
         public override bool RequiresExecution()
         {
-            return _status == InstallStatusType.NewInstall;
+            if (InstalledPackage.GetAllInstalledPackages().Count > 0)
+                return false;
+
+            if (_applicationContext.Services.ContentService.GetRootContent().Any())
+                return false;
+
+            var installSteps = InstallStatusTracker.GetStatus().ToArray();
+            //this step relies on the preious one completed - because it has stored some information we need
+            if (installSteps.Any(x => x.Name == "StarterKitDownload") == false)
+            {
+                return false;
+            }
+
+            return true;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Install/InstallSteps/Upgrade.cs b/src/Umbraco.Web/Install/InstallSteps/Upgrade.cs
new file mode 100644
index 0000000000..46e48ca1d0
--- /dev/null
+++ b/src/Umbraco.Web/Install/InstallSteps/Upgrade.cs
@@ -0,0 +1,22 @@
+using Umbraco.Web.Install.Models;
+
+namespace Umbraco.Web.Install.InstallSteps
+{
+    /// <summary>
+    /// This step is purely here to show the button to commence the upgrade
+    /// </summary>
+    [InstallSetupStep(InstallationType.Upgrade,
+        "Upgrade", "upgrade", 1, "Upgrading umbraco")]
+    internal class Upgrade : InstallSetupStep<object>
+    {
+        public override bool RequiresExecution()
+        {
+            return true;
+        }
+
+        public override InstallSetupResult Execute(object model)
+        {
+            return null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Install/InstallSteps/UserStep.cs b/src/Umbraco.Web/Install/InstallSteps/UserStep.cs
index 33d7eabd02..cb52643efd 100644
--- a/src/Umbraco.Web/Install/InstallSteps/UserStep.cs
+++ b/src/Umbraco.Web/Install/InstallSteps/UserStep.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Web.Security;
 using Umbraco.Core;
 using Umbraco.Core.Configuration;
@@ -8,16 +9,15 @@ using Umbraco.Web.Install.Models;
 namespace Umbraco.Web.Install.InstallSteps
 {
 
-    [InstallSetupStep("User", "user", 20, "Saving your user credentials")]
+    [InstallSetupStep(InstallationType.NewInstall,
+        "User", "user", 20, "Saving your user credentials")]
     internal class UserStep : InstallSetupStep<UserModel>
     {
         private readonly ApplicationContext _applicationContext;
-        private readonly InstallStatusType _status;
 
-        public UserStep(ApplicationContext applicationContext, InstallStatusType status)
+        public UserStep(ApplicationContext applicationContext)
         {
             _applicationContext = applicationContext;
-            _status = status;
         }
 
         private MembershipProvider CurrentProvider
@@ -71,12 +71,34 @@ namespace Umbraco.Web.Install.InstallSteps
 
         public override string View
         {
-            get { return _status == InstallStatusType.NewInstall ? base.View : string.Empty; }
+            get { return RequiresExecution() ? base.View : string.Empty; }
         }
 
         public override bool RequiresExecution()
         {
-            return _status == InstallStatusType.NewInstall;
+            //if there's already a version then there should def be a user
+            if (GlobalSettings.ConfigurationStatus.IsNullOrWhiteSpace() == false) return false;
+
+            //now we have to check if this is really a new install, the db might be configured and might contain data
+            var databaseSettings = ConfigurationManager.ConnectionStrings[GlobalSettings.UmbracoConnectionName];
+
+            if (_applicationContext.DatabaseContext.IsConnectionStringConfigured(databaseSettings)
+                && _applicationContext.DatabaseContext.IsDatabaseConfigured)
+            {
+                //check if we have the default user configured already
+                var result = _applicationContext.DatabaseContext.Database.ExecuteScalar<int>(
+                    "SELECT COUNT(*) FROM umbracoUser WHERE id=0 AND userPassword='default'");
+                if (result == 1)
+                {
+                    //the user has not been configured
+                    return true;
+                }
+                return false;
+            }
+            else
+            {
+                return true;
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Install/Models/InstallSetup.cs b/src/Umbraco.Web/Install/Models/InstallSetup.cs
index 65784d4b6a..55f66f13d6 100644
--- a/src/Umbraco.Web/Install/Models/InstallSetup.cs
+++ b/src/Umbraco.Web/Install/Models/InstallSetup.cs
@@ -13,15 +13,12 @@ namespace Umbraco.Web.Install.Models
         public InstallSetup()
         {
             Steps = new List<InstallSetupStep>();
-            InstallationId = Guid.NewGuid();
+            InstallId = Guid.NewGuid();
         }
 
         [DataMember(Name = "installId")]
-        public Guid InstallationId { get; private set; }
-
-        [DataMember(Name = "status")]
-        public InstallStatusType Status { get; set; }
-
+        public Guid InstallId { get; private set; }
+        
         [DataMember(Name = "steps")]
         public IEnumerable<InstallSetupStep> Steps { get; set; } 
 
diff --git a/src/Umbraco.Web/Install/Models/InstallSetupStep.cs b/src/Umbraco.Web/Install/Models/InstallSetupStep.cs
index 7b96ca3465..37aac64539 100644
--- a/src/Umbraco.Web/Install/Models/InstallSetupStep.cs
+++ b/src/Umbraco.Web/Install/Models/InstallSetupStep.cs
@@ -41,6 +41,7 @@ namespace Umbraco.Web.Install.Models
             View = att.View;
             ServerOrder = att.ServerOrder;
             Description = att.Description;
+            InstallTypeTarget = att.InstallTypeTarget;
         }
 
         [DataMember(Name = "name")]
@@ -51,9 +52,12 @@ namespace Umbraco.Web.Install.Models
 
         [DataMember(Name = "description")]
         public string Description { get; private set; }
+
+        [IgnoreDataMember]
+        public InstallationType InstallTypeTarget { get; private set; }
         
         /// <summary>
-        /// Determines if this step needs to execute given it's ctor arguments
+        /// Determines if this step needs to execute based on the current state of the application and/or install process
         /// </summary>
         /// <returns></returns>
         public abstract bool RequiresExecution();
diff --git a/src/Umbraco.Web/Install/Models/InstallSetupStepAttribute.cs b/src/Umbraco.Web/Install/Models/InstallSetupStepAttribute.cs
index f8825c8a5c..d083e4733a 100644
--- a/src/Umbraco.Web/Install/Models/InstallSetupStepAttribute.cs
+++ b/src/Umbraco.Web/Install/Models/InstallSetupStepAttribute.cs
@@ -1,25 +1,31 @@
 using System;
+using System.Text.RegularExpressions;
 
 namespace Umbraco.Web.Install.Models
 {
     public sealed class InstallSetupStepAttribute : Attribute
     {
-        public InstallSetupStepAttribute(string name, string view, int serverOrder, string description)
+        public InstallSetupStepAttribute(InstallationType installTypeTarget, string name, string view, int serverOrder, string description)
         {
+            InstallTypeTarget = installTypeTarget;
             Name = name;
             View = view;
             ServerOrder = serverOrder;
             Description = description;
+
+            var r = new Regex("", RegexOptions.Compiled | RegexOptions.Compiled);
         }
 
-        public InstallSetupStepAttribute(string name, int serverOrder, string description)
+        public InstallSetupStepAttribute(InstallationType installTypeTarget, string name, int serverOrder, string description)
         {
+            InstallTypeTarget = installTypeTarget;
             Name = name;
             View = string.Empty;
             ServerOrder = serverOrder;
             Description = description;
         }
 
+        public InstallationType InstallTypeTarget { get; private set; }
         public string Name { get; private set; }
         public string View { get; private set; }
         public int ServerOrder { get; private set; }
diff --git a/src/Umbraco.Web/Install/Models/InstallStatusType.cs b/src/Umbraco.Web/Install/Models/InstallStatusType.cs
deleted file mode 100644
index 727db4028b..0000000000
--- a/src/Umbraco.Web/Install/Models/InstallStatusType.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using System;
-using System.Collections;
-using System.Linq;
-using System.Runtime.Serialization;
-using System.ServiceModel.ComIntegration;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Umbraco.Web.Install.Models
-{
-    public enum InstallStatusType
-    {
-        NewInstall,
-        Upgrade,
-
-        /// <summary>
-        /// Used when we detect an upgrade but there is no user token associated
-        /// </summary>
-        UpgradeWithoutToken,
-
-        ///// <summary>
-        ///// Used if the user presses f5 and is in the middle of an install
-        ///// </summary>
-        //InProgress
-    }
-
-}
diff --git a/src/Umbraco.Web/Install/Models/InstallationType.cs b/src/Umbraco.Web/Install/Models/InstallationType.cs
new file mode 100644
index 0000000000..cfedb8b850
--- /dev/null
+++ b/src/Umbraco.Web/Install/Models/InstallationType.cs
@@ -0,0 +1,11 @@
+using System;
+
+namespace Umbraco.Web.Install.Models
+{
+    [Flags]
+    public enum InstallationType
+    {
+        NewInstall =    1 << 0,    // 1
+        Upgrade =       1 << 1,       // 2
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 7b93ea46a9..0cfdf8779e 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -313,9 +313,11 @@
     <Compile Include="Install\InstallSteps\StarterKitCleanupStep.cs" />
     <Compile Include="Install\InstallSteps\StarterKitDownloadStep.cs" />
     <Compile Include="Install\InstallSteps\StarterKitInstallStep.cs" />
+    <Compile Include="Install\InstallSteps\Upgrade.cs" />
     <Compile Include="Install\InstallSteps\UserStep.cs" />
     <Compile Include="Install\Models\DatabaseModel.cs" />
     <Compile Include="Install\Models\DatabaseType.cs" />
+    <Compile Include="Install\Models\InstallationType.cs" />
     <Compile Include="Install\Models\InstallInstructions.cs" />
     <Compile Include="Install\Models\InstallSetup.cs" />
     <Compile Include="Install\Models\InstallSetupResult.cs" />
@@ -328,7 +330,6 @@
     <Compile Include="Install\Controllers\InstallApiController.cs" />
     <Compile Include="Install\Controllers\InstallController.cs" />
     <Compile Include="Install\InstallAuthorizeAttribute.cs" />
-    <Compile Include="Install\Models\InstallStatusType.cs" />
     <Compile Include="MediaPropertyExtensions.cs" />
     <Compile Include="Models\ContentEditing\EntityTypeSearchResult.cs" />
     <Compile Include="Models\ContentEditing\ListViewAwareContentItemDisplayBase.cs" />