diff --git a/Data/Data.csproj b/Data/Data.csproj
index aecd12df..135585ae 100644
--- a/Data/Data.csproj
+++ b/Data/Data.csproj
@@ -10,6 +10,7 @@
     <Compile Remove="Migrations\20181006003838_CreateIdentitySchema.cs" />
     <Compile Remove="Migrations\20190111053724_EventId.cs" />
     <Compile Remove="Migrations\20190111053724_EventId.Designer.cs" />
+    <Compile Remove="Migrations\20190214050904_CheatsAndWhistles.cs" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Data/DataModel/Puzzle.cs b/Data/DataModel/Puzzle.cs
index e5bd0edf..5fda4126 100644
--- a/Data/DataModel/Puzzle.cs
+++ b/Data/DataModel/Puzzle.cs
@@ -25,6 +25,7 @@ public Puzzle (Puzzle source)
             IsPuzzle = source.IsPuzzle;
             IsMetaPuzzle = source.IsMetaPuzzle;
             IsFinalPuzzle = source.IsFinalPuzzle;
+            IsCheatCode = source.IsCheatCode;
             SolveValue = source.SolveValue;
             HintCoinsForSolve = source.HintCoinsForSolve;
             Token = source.Token;
@@ -33,6 +34,9 @@ public Puzzle (Puzzle source)
             IsGloballyVisiblePrerequisite = source.IsGloballyVisiblePrerequisite;
             MinPrerequisiteCount = source.MinPrerequisiteCount;
             MinutesToAutomaticallySolve = source.MinutesToAutomaticallySolve;
+            MinutesOfEventLockout = source.MinutesOfEventLockout;
+            MaxAnnotationKey = source.MaxAnnotationKey;
+            SupportEmailAlias = source.SupportEmailAlias;
         }
 
         /// <summary>
@@ -67,6 +71,11 @@ public Puzzle (Puzzle source)
         /// </summary>
         public bool IsFinalPuzzle { get; set; } = false;
 
+        /// <summary>
+        /// True if this puzzle is a "cheat code" (nee "Fast Forward") that should impact standings
+        /// </summary>
+        public bool IsCheatCode { get; set; }
+
         /// <summary>
         /// The solve value
         /// </summary>
@@ -111,6 +120,11 @@ public Puzzle (Puzzle source)
         /// </summary>
         public int? MinutesToAutomaticallySolve { get; set; } = null;
 
+        /// <summary>
+        /// How long to lock solvers out of the rest of the event
+        /// </summary>
+        public int MinutesOfEventLockout { get; set; }
+
         /// <summary>
         /// Some puzzles let teams store annotations describing their ongoing work, so they can share those
         /// with their teammates.  However, we don't want to let teams store arbitrary annotation data,
@@ -137,6 +151,10 @@ public Puzzle (Puzzle source)
         /// </summary>
         public string SupportEmailAlias { get; set; }
 
+        //
+        // WARNING: If you add new properties add them to the constructor as well so importing will work.
+        //
+
         /// <summary>
         /// File for the main puzzle (typically a PDF containing the puzzle)
         /// </summary>
@@ -199,5 +217,9 @@ public IEnumerable<ContentFile> SolveTokenFiles
         }        
 
         public virtual List<Submission> Submissions { get; set; }
+
+        //
+        // WARNING: If you add new properties add them to the constructor as well so importing will work.
+        //
     }
 }
\ No newline at end of file
diff --git a/Data/Migrations/20190218005038_CheatsAndWhistles.Designer.cs b/Data/Migrations/20190218005038_CheatsAndWhistles.Designer.cs
new file mode 100644
index 00000000..eaac7e6c
--- /dev/null
+++ b/Data/Migrations/20190218005038_CheatsAndWhistles.Designer.cs
@@ -0,0 +1,940 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using ServerCore.DataModel;
+
+namespace Data.Migrations
+{
+    [DbContext(typeof(PuzzleServerContext))]
+    [Migration("20190218005038_CheatsAndWhistles")]
+    partial class CheatsAndWhistles
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.1.8-servicing-32085")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex")
+                        .HasFilter("[NormalizedName] IS NOT NULL");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex")
+                        .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128);
+
+                    b.Property<string>("ProviderKey")
+                        .HasMaxLength(128);
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(128);
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(128);
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.ContentFile", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("EventID");
+
+                    b.Property<int>("FileType");
+
+                    b.Property<int?>("PuzzleID")
+                        .IsRequired();
+
+                    b.Property<string>("ShortName")
+                        .IsRequired();
+
+                    b.Property<string>("UrlString")
+                        .IsRequired();
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("PuzzleID");
+
+                    b.HasIndex("EventID", "ShortName")
+                        .IsUnique();
+
+                    b.ToTable("ContentFiles");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Event", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<bool>("AllowFeedback");
+
+                    b.Property<DateTime>("AnswerSubmissionEnd");
+
+                    b.Property<DateTime>("AnswersAvailableBegin");
+
+                    b.Property<string>("ContactEmail");
+
+                    b.Property<DateTime>("EventBegin");
+
+                    b.Property<string>("HomePartial");
+
+                    b.Property<bool>("IsInternEvent");
+
+                    b.Property<double>("LockoutDurationMultiplier");
+
+                    b.Property<int>("LockoutIncorrectGuessLimit");
+
+                    b.Property<double>("LockoutIncorrectGuessPeriod");
+
+                    b.Property<int>("MaxExternalsPerTeam");
+
+                    b.Property<int>("MaxNumberOfTeams");
+
+                    b.Property<long>("MaxSubmissionCount");
+
+                    b.Property<int>("MaxTeamSize");
+
+                    b.Property<string>("Name")
+                        .IsRequired();
+
+                    b.Property<bool>("ShowFastestSolves");
+
+                    b.Property<DateTime>("StandingsAvailableBegin");
+
+                    b.Property<bool>("StandingsOverride");
+
+                    b.Property<DateTime>("TeamDeleteEnd");
+
+                    b.Property<DateTime>("TeamMembershipChangeEnd");
+
+                    b.Property<DateTime>("TeamMiscDataChangeEnd");
+
+                    b.Property<DateTime>("TeamNameChangeEnd");
+
+                    b.Property<DateTime>("TeamRegistrationBegin");
+
+                    b.Property<DateTime>("TeamRegistrationEnd");
+
+                    b.Property<string>("UrlString");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("UrlString")
+                        .IsUnique()
+                        .HasFilter("[UrlString] IS NOT NULL");
+
+                    b.ToTable("Events");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.EventAdmins", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("Event.ID");
+
+                    b.Property<int?>("User.ID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Event.ID")
+                        .IsUnique()
+                        .HasFilter("[Event.ID] IS NOT NULL");
+
+                    b.HasIndex("User.ID");
+
+                    b.ToTable("EventAdmins");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.EventAuthors", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("Event.ID");
+
+                    b.Property<int?>("User.ID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Event.ID")
+                        .IsUnique()
+                        .HasFilter("[Event.ID] IS NOT NULL");
+
+                    b.HasIndex("User.ID");
+
+                    b.ToTable("EventAuthors");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.EventTeams", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("Event.ID");
+
+                    b.Property<int?>("Teams.ID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Event.ID")
+                        .IsUnique()
+                        .HasFilter("[Event.ID] IS NOT NULL");
+
+                    b.HasIndex("Teams.ID");
+
+                    b.ToTable("EventTeams");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Feedback", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("Difficulty");
+
+                    b.Property<int>("Fun");
+
+                    b.Property<int?>("PuzzleID");
+
+                    b.Property<DateTime>("SubmissionTime");
+
+                    b.Property<int?>("SubmitterID");
+
+                    b.Property<string>("WrittenFeedback");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("PuzzleID");
+
+                    b.HasIndex("SubmitterID");
+
+                    b.ToTable("Feedback");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Hint", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Content")
+                        .IsRequired();
+
+                    b.Property<int>("Cost");
+
+                    b.Property<string>("Description")
+                        .IsRequired();
+
+                    b.Property<int>("DisplayOrder");
+
+                    b.Property<int>("PuzzleID");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PuzzleID");
+
+                    b.ToTable("Hints");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.HintStatePerTeam", b =>
+                {
+                    b.Property<int>("TeamID");
+
+                    b.Property<int>("HintID");
+
+                    b.Property<DateTime?>("UnlockTime");
+
+                    b.HasKey("TeamID", "HintID");
+
+                    b.HasIndex("HintID");
+
+                    b.ToTable("HintStatePerTeam");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Invitation", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("EmailAddress");
+
+                    b.Property<DateTime>("Expiration");
+
+                    b.Property<Guid>("InvitationCode");
+
+                    b.Property<string>("InvitationType");
+
+                    b.Property<int?>("TeamID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("TeamID");
+
+                    b.ToTable("Invitations");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Prerequisites", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("PrerequisiteID");
+
+                    b.Property<int>("PuzzleID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("PrerequisiteID");
+
+                    b.HasIndex("PuzzleID");
+
+                    b.ToTable("Prerequisites");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Puzzle", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("EventID");
+
+                    b.Property<string>("Group");
+
+                    b.Property<int>("HintCoinsForSolve");
+
+                    b.Property<bool>("IsCheatCode");
+
+                    b.Property<bool>("IsFinalPuzzle");
+
+                    b.Property<bool>("IsGloballyVisiblePrerequisite");
+
+                    b.Property<bool>("IsMetaPuzzle");
+
+                    b.Property<bool>("IsPuzzle");
+
+                    b.Property<int>("MaxAnnotationKey");
+
+                    b.Property<int>("MinPrerequisiteCount");
+
+                    b.Property<int>("MinutesOfEventLockout");
+
+                    b.Property<int?>("MinutesToAutomaticallySolve");
+
+                    b.Property<string>("Name")
+                        .IsRequired();
+
+                    b.Property<int>("OrderInGroup");
+
+                    b.Property<int>("SolveValue");
+
+                    b.Property<string>("SupportEmailAlias");
+
+                    b.Property<string>("Token");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("EventID");
+
+                    b.ToTable("Puzzles");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.PuzzleAuthors", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("AuthorID");
+
+                    b.Property<int>("PuzzleID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("AuthorID");
+
+                    b.HasIndex("PuzzleID");
+
+                    b.ToTable("PuzzleAuthors");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.PuzzleStatePerTeam", b =>
+                {
+                    b.Property<int>("PuzzleID");
+
+                    b.Property<int>("TeamID");
+
+                    b.Property<bool>("IsEmailOnlyMode");
+
+                    b.Property<DateTime?>("LockoutExpiryTime");
+
+                    b.Property<string>("Notes");
+
+                    b.Property<bool>("Printed");
+
+                    b.Property<DateTime?>("SolvedTime");
+
+                    b.Property<DateTime?>("UnlockedTime");
+
+                    b.Property<long>("WrongSubmissionCountBuffer");
+
+                    b.HasKey("PuzzleID", "TeamID");
+
+                    b.HasIndex("TeamID");
+
+                    b.ToTable("PuzzleStatePerTeam");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.PuzzleUser", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Email");
+
+                    b.Property<string>("EmployeeAlias");
+
+                    b.Property<string>("IdentityUserId")
+                        .IsRequired();
+
+                    b.Property<bool>("IsGlobalAdmin");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<string>("TShirtSize");
+
+                    b.Property<bool>("VisibleToOthers");
+
+                    b.HasKey("ID");
+
+                    b.ToTable("PuzzleUsers");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Response", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<bool>("IsSolution");
+
+                    b.Property<string>("Note");
+
+                    b.Property<int>("PuzzleID");
+
+                    b.Property<string>("ResponseText")
+                        .IsRequired();
+
+                    b.Property<string>("SubmittedText")
+                        .IsRequired();
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("PuzzleID");
+
+                    b.ToTable("Responses");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Submission", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("PuzzleID");
+
+                    b.Property<int?>("ResponseID");
+
+                    b.Property<string>("SubmissionText")
+                        .IsRequired();
+
+                    b.Property<int?>("SubmitterID");
+
+                    b.Property<int?>("TeamID");
+
+                    b.Property<DateTime>("TimeSubmitted");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("PuzzleID");
+
+                    b.HasIndex("ResponseID");
+
+                    b.HasIndex("SubmitterID");
+
+                    b.HasIndex("TeamID");
+
+                    b.ToTable("Submissions");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Team", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CustomRoom");
+
+                    b.Property<int?>("EventID");
+
+                    b.Property<int>("HintCoinCount");
+
+                    b.Property<int>("HintCoinsUsed");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("PrimaryContactEmail");
+
+                    b.Property<string>("PrimaryPhoneNumber");
+
+                    b.Property<int?>("RoomID");
+
+                    b.Property<string>("SecondaryPhoneNumber");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("EventID");
+
+                    b.ToTable("Teams");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.TeamApplication", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("PlayerID");
+
+                    b.Property<int>("TeamID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("PlayerID");
+
+                    b.HasIndex("TeamID");
+
+                    b.ToTable("TeamApplications");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.TeamMembers", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int?>("Team.ID");
+
+                    b.Property<int?>("User.ID");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Team.ID");
+
+                    b.HasIndex("User.ID");
+
+                    b.ToTable("TeamMembers");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.ContentFile", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Event", "Event")
+                        .WithMany()
+                        .HasForeignKey("EventID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ServerCore.DataModel.Puzzle", "Puzzle")
+                        .WithMany("Contents")
+                        .HasForeignKey("PuzzleID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.EventAdmins", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Event", "Event")
+                        .WithOne("Admins")
+                        .HasForeignKey("ServerCore.DataModel.EventAdmins", "Event.ID");
+
+                    b.HasOne("ServerCore.DataModel.PuzzleUser", "Admin")
+                        .WithMany()
+                        .HasForeignKey("User.ID");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.EventAuthors", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Event", "Event")
+                        .WithOne("Authors")
+                        .HasForeignKey("ServerCore.DataModel.EventAuthors", "Event.ID");
+
+                    b.HasOne("ServerCore.DataModel.PuzzleUser", "Author")
+                        .WithMany()
+                        .HasForeignKey("User.ID");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.EventTeams", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Event", "Event")
+                        .WithOne("Teams")
+                        .HasForeignKey("ServerCore.DataModel.EventTeams", "Event.ID");
+
+                    b.HasOne("ServerCore.DataModel.Team", "Team")
+                        .WithMany()
+                        .HasForeignKey("Teams.ID");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Feedback", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Puzzle", "Puzzle")
+                        .WithMany()
+                        .HasForeignKey("PuzzleID");
+
+                    b.HasOne("ServerCore.DataModel.PuzzleUser", "Submitter")
+                        .WithMany()
+                        .HasForeignKey("SubmitterID");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Hint", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Puzzle", "Puzzle")
+                        .WithMany("Hints")
+                        .HasForeignKey("PuzzleID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.HintStatePerTeam", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Hint", "Hint")
+                        .WithMany()
+                        .HasForeignKey("HintID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ServerCore.DataModel.Team", "Team")
+                        .WithMany()
+                        .HasForeignKey("TeamID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Invitation", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Team")
+                        .WithMany("Invitations")
+                        .HasForeignKey("TeamID");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Prerequisites", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Puzzle", "Prerequisite")
+                        .WithMany()
+                        .HasForeignKey("PrerequisiteID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ServerCore.DataModel.Puzzle", "Puzzle")
+                        .WithMany()
+                        .HasForeignKey("PuzzleID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Puzzle", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Event", "Event")
+                        .WithMany()
+                        .HasForeignKey("EventID");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.PuzzleAuthors", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.PuzzleUser", "Author")
+                        .WithMany()
+                        .HasForeignKey("AuthorID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ServerCore.DataModel.Puzzle", "Puzzle")
+                        .WithMany()
+                        .HasForeignKey("PuzzleID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.PuzzleStatePerTeam", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Puzzle", "Puzzle")
+                        .WithMany()
+                        .HasForeignKey("PuzzleID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ServerCore.DataModel.Team", "Team")
+                        .WithMany()
+                        .HasForeignKey("TeamID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Response", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Puzzle", "Puzzle")
+                        .WithMany()
+                        .HasForeignKey("PuzzleID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Submission", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Puzzle", "Puzzle")
+                        .WithMany("Submissions")
+                        .HasForeignKey("PuzzleID");
+
+                    b.HasOne("ServerCore.DataModel.Response", "Response")
+                        .WithMany()
+                        .HasForeignKey("ResponseID");
+
+                    b.HasOne("ServerCore.DataModel.PuzzleUser", "Submitter")
+                        .WithMany()
+                        .HasForeignKey("SubmitterID");
+
+                    b.HasOne("ServerCore.DataModel.Team", "Team")
+                        .WithMany("Submissions")
+                        .HasForeignKey("TeamID");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.Team", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Event", "Event")
+                        .WithMany()
+                        .HasForeignKey("EventID");
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.TeamApplication", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.PuzzleUser", "Player")
+                        .WithMany()
+                        .HasForeignKey("PlayerID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ServerCore.DataModel.Team", "Team")
+                        .WithMany()
+                        .HasForeignKey("TeamID")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ServerCore.DataModel.TeamMembers", b =>
+                {
+                    b.HasOne("ServerCore.DataModel.Team", "Team")
+                        .WithMany()
+                        .HasForeignKey("Team.ID");
+
+                    b.HasOne("ServerCore.DataModel.PuzzleUser", "Member")
+                        .WithMany()
+                        .HasForeignKey("User.ID");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Data/Migrations/20190218005038_CheatsAndWhistles.cs b/Data/Migrations/20190218005038_CheatsAndWhistles.cs
new file mode 100644
index 00000000..37fe0b0e
--- /dev/null
+++ b/Data/Migrations/20190218005038_CheatsAndWhistles.cs
@@ -0,0 +1,33 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Data.Migrations
+{
+    public partial class CheatsAndWhistles : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsCheatCode",
+                table: "Puzzles",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MinutesOfEventLockout",
+                table: "Puzzles",
+                nullable: false,
+                defaultValue: 0);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsCheatCode",
+                table: "Puzzles");
+
+            migrationBuilder.DropColumn(
+                name: "MinutesOfEventLockout",
+                table: "Puzzles");
+        }
+    }
+}
diff --git a/Data/Migrations/PuzzleServerContextModelSnapshot.cs b/Data/Migrations/PuzzleServerContextModelSnapshot.cs
index 326854c2..159af1af 100644
--- a/Data/Migrations/PuzzleServerContextModelSnapshot.cs
+++ b/Data/Migrations/PuzzleServerContextModelSnapshot.cs
@@ -15,7 +15,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "2.1.4-rtm-31024")
+                .HasAnnotation("ProductVersion", "2.1.8-servicing-32085")
                 .HasAnnotation("Relational:MaxIdentifierLength", 128)
                 .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
@@ -463,6 +463,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.Property<int>("HintCoinsForSolve");
 
+                    b.Property<bool>("IsCheatCode");
+
                     b.Property<bool>("IsFinalPuzzle");
 
                     b.Property<bool>("IsGloballyVisiblePrerequisite");
@@ -475,6 +477,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.Property<int>("MinPrerequisiteCount");
 
+                    b.Property<int>("MinutesOfEventLockout");
+
                     b.Property<int?>("MinutesToAutomaticallySolve");
 
                     b.Property<string>("Name")
diff --git a/ServerCore/Pages/Events/CreateDemo.cshtml.cs b/ServerCore/Pages/Events/CreateDemo.cshtml.cs
index 702af8b6..8c41b43d 100644
--- a/ServerCore/Pages/Events/CreateDemo.cshtml.cs
+++ b/ServerCore/Pages/Events/CreateDemo.cshtml.cs
@@ -163,6 +163,44 @@ public async Task<IActionResult> OnPostAsync()
                 };
                 _context.Puzzles.Add(other);
 
+                Puzzle cheat = new Puzzle
+                {
+                    Name = "You're Despicable (cheat code)",
+                    Event = Event,
+                    IsPuzzle = true,
+                    IsCheatCode = true,
+                    SolveValue = -1,
+                    Group = "Daffy's Delights",
+                    OrderInGroup = 2,
+                    MinPrerequisiteCount = 1
+                };
+                _context.Puzzles.Add(cheat);
+
+                Puzzle lockIntro = new Puzzle
+                {
+                    Name = "Wouldn't you know... (whistle stop intro)",
+                    Event = Event,
+                    IsPuzzle = true,
+                    SolveValue = 0,
+                    Group = "Roger's Railway",
+                    OrderInGroup = 1,
+                    MinPrerequisiteCount = 1
+                };
+                _context.Puzzles.Add(lockIntro);
+
+                Puzzle lockPuzzle = new Puzzle
+                {
+                    Name = "...Locked! (whistle stop, lasts 5 minutes)",
+                    Event = Event,
+                    IsPuzzle = true,
+                    SolveValue = 0,
+                    Group = "Roger's Railway",
+                    OrderInGroup = 2,
+                    MinPrerequisiteCount = 1,
+                    MinutesOfEventLockout = 5
+                };
+                _context.Puzzles.Add(lockPuzzle);
+
                 await _context.SaveChangesAsync();
 
                 //
@@ -178,6 +216,12 @@ public async Task<IActionResult> OnPostAsync()
                 _context.Responses.Add(new Response() { Puzzle = meta, SubmittedText = "ANSWER", ResponseText = "Correct!", IsSolution = true });
                 _context.Responses.Add(new Response() { Puzzle = other, SubmittedText = "PARTIAL", ResponseText = "Keep going..." });
                 _context.Responses.Add(new Response() { Puzzle = other, SubmittedText = "ANSWER", ResponseText = "Correct!", IsSolution = true });
+                _context.Responses.Add(new Response() { Puzzle = cheat, SubmittedText = "PARTIAL", ResponseText = "Keep going..." });
+                _context.Responses.Add(new Response() { Puzzle = cheat, SubmittedText = "ANSWER", ResponseText = "Correct!", IsSolution = true });
+                _context.Responses.Add(new Response() { Puzzle = lockIntro, SubmittedText = "PARTIAL", ResponseText = "Keep going..." });
+                _context.Responses.Add(new Response() { Puzzle = lockIntro, SubmittedText = "ANSWER", ResponseText = "Correct!", IsSolution = true });
+                _context.Responses.Add(new Response() { Puzzle = lockPuzzle, SubmittedText = "PARTIAL", ResponseText = "Keep going..." });
+                _context.Responses.Add(new Response() { Puzzle = lockPuzzle, SubmittedText = "ANSWER", ResponseText = "Correct!", IsSolution = true });
 
                 string hint1Description = "Tell me about the rabbits, George.";
                 string hint1Content = "O.K. Some day – we’re gonna get the jack together and we’re gonna have a little house and a couple of acres an’ a cow and some pigs and...";
@@ -206,6 +250,9 @@ public async Task<IActionResult> OnPostAsync()
                 _context.Prerequisites.Add(new Prerequisites() { Puzzle = meta, Prerequisite = intermediate });
                 _context.Prerequisites.Add(new Prerequisites() { Puzzle = meta, Prerequisite = hard });
                 _context.Prerequisites.Add(new Prerequisites() { Puzzle = other, Prerequisite = start });
+                _context.Prerequisites.Add(new Prerequisites() { Puzzle = cheat, Prerequisite = start });
+                _context.Prerequisites.Add(new Prerequisites() { Puzzle = lockIntro, Prerequisite = start });
+                _context.Prerequisites.Add(new Prerequisites() { Puzzle = lockPuzzle, Prerequisite = lockIntro });
 
                 await _context.SaveChangesAsync();
 
diff --git a/ServerCore/Pages/Events/Map.cshtml b/ServerCore/Pages/Events/Map.cshtml
index 004bd073..968b47f6 100644
--- a/ServerCore/Pages/Events/Map.cshtml
+++ b/ServerCore/Pages/Events/Map.cshtml
@@ -28,7 +28,7 @@
                     @foreach (var puzzle in Model.Puzzles)
                     {
                         <th>
-                            <a asp-page="/Puzzles/Status" asp-route-id="@puzzle.Puzzle.ID">@(puzzle.Puzzle.Name) (@puzzle.SolveCount)</a>
+                            <a asp-page="/Puzzles/Status" asp-route-puzzleId="@puzzle.Puzzle.ID">@(puzzle.Puzzle.Name) (@puzzle.SolveCount)</a>
                         </th>
                     }
                 </tr>
@@ -41,7 +41,7 @@
                         @(team.Rank)
                     </td>
                     <td>
-                        <a asp-page="/Teams/Status" asp-route-id="@team.Team.ID">@(team.Team.Name)</a>
+                        <a asp-page="/Teams/Status" asp-route-teamId="@team.Team.ID">@(team.Team.Name)</a>
                     </td>
                     <td>
                         @Html.DisplayFor(modelItem => team.SolveCount)
diff --git a/ServerCore/Pages/Events/Map.cshtml.cs b/ServerCore/Pages/Events/Map.cshtml.cs
index 2eff1e5e..98f9a8c6 100644
--- a/ServerCore/Pages/Events/Map.cshtml.cs
+++ b/ServerCore/Pages/Events/Map.cshtml.cs
@@ -67,7 +67,13 @@ public async Task<IActionResult> OnGetAsync()
                     team.SolveCount++;
                     team.Score += puzzle.Puzzle.SolveValue;
 
-                    if (puzzle.Puzzle.IsFinalPuzzle)
+                    if (puzzle.Puzzle.IsCheatCode)
+                    {
+                        team.CheatCodeUsed = true;
+                        team.FinalMetaSolveTime = DateTime.MaxValue;
+                    }
+
+                    if (puzzle.Puzzle.IsFinalPuzzle && !team.CheatCodeUsed)
                     {
                         team.FinalMetaSolveTime = state.SolvedTime.Value;
                     }
@@ -118,6 +124,7 @@ public class TeamStats
             public int Score { get; set; }
             public int SortOrder { get; set; }
             public int? Rank { get; set; }
+            public bool CheatCodeUsed { get; set; }
             public DateTime FinalMetaSolveTime { get; set; } = DateTime.MaxValue;
         }
 
diff --git a/ServerCore/Pages/Events/Standings.cshtml.cs b/ServerCore/Pages/Events/Standings.cshtml.cs
index 994ed2e9..d59df570 100644
--- a/ServerCore/Pages/Events/Standings.cshtml.cs
+++ b/ServerCore/Pages/Events/Standings.cshtml.cs
@@ -32,7 +32,9 @@ public async Task OnGetAsync(SortOrder? sort)
                     Team = g.Key,
                     SolveCount = g.Count(),
                     Score = g.Sum(s => s.Puzzle.SolveValue),
-                    FinalMetaSolveTime = g.Where(s => s.Puzzle.IsFinalPuzzle).Select(s => s.SolvedTime).FirstOrDefault() ?? DateTime.MaxValue
+                    FinalMetaSolveTime = g.Where(s => s.Puzzle.IsCheatCode).Any() ?
+                        DateTime.MaxValue :
+                        (g.Where(s => s.Puzzle.IsFinalPuzzle).Select(s => s.SolvedTime).FirstOrDefault() ?? DateTime.MaxValue)
                 })
                 .OrderBy(t => t.FinalMetaSolveTime).ThenByDescending(t => t.Score).ThenBy(t => t.Team.Name)
                 .ToListAsync();
diff --git a/ServerCore/Pages/Puzzles/Create.cshtml b/ServerCore/Pages/Puzzles/Create.cshtml
index 917ba1dc..4214bad9 100644
--- a/ServerCore/Pages/Puzzles/Create.cshtml
+++ b/ServerCore/Pages/Puzzles/Create.cshtml
@@ -45,6 +45,13 @@
                     </label>
                 </div>
             </div>
+            <div class="form-group">
+                <div class="checkbox">
+                    <label>
+                        <input asp-for="Puzzle.IsCheatCode" /> @Html.DisplayNameFor(model => model.Puzzle.IsCheatCode)
+                    </label>
+                </div>
+            </div>
             <div class="form-group">
                 <label asp-for="Puzzle.SolveValue" class="control-label"></label>
                 <input asp-for="Puzzle.SolveValue" class="form-control" />
@@ -87,6 +94,11 @@
                 <input asp-for="Puzzle.MinutesToAutomaticallySolve" class="form-control" />
                 <span asp-validation-for="Puzzle.MinutesToAutomaticallySolve" class="text-danger"></span>
             </div>
+            <div class="form-group">
+                <label asp-for="Puzzle.MinutesOfEventLockout" class="control-label"></label>
+                <input asp-for="Puzzle.MinutesOfEventLockout" class="form-control" />
+                <span asp-validation-for="Puzzle.MinutesOfEventLockout" class="text-danger"></span>
+            </div>
             <div class="form-group">
                 <label asp-for="Puzzle.MaxAnnotationKey" class="control-label"></label>
                 <input asp-for="Puzzle.MaxAnnotationKey" class="form-control" />
diff --git a/ServerCore/Pages/Puzzles/Delete.cshtml b/ServerCore/Pages/Puzzles/Delete.cshtml
index 7490f6ab..8bde177c 100644
--- a/ServerCore/Pages/Puzzles/Delete.cshtml
+++ b/ServerCore/Pages/Puzzles/Delete.cshtml
@@ -45,6 +45,12 @@
         <dd>
             @Html.DisplayFor(model => model.Puzzle.IsFinalPuzzle)
         </dd>
+        <dt>
+            @Html.DisplayNameFor(model => model.Puzzle.IsCheatCode)
+        </dt>
+        <dd>
+            @Html.DisplayFor(model => model.Puzzle.IsCheatCode)
+        </dd>
         <dt>
             @Html.DisplayNameFor(model => model.Puzzle.SolveValue)
         </dt>
@@ -87,6 +93,12 @@
         <dd>
             @Html.DisplayFor(model => model.Puzzle.MinutesToAutomaticallySolve)
         </dd>
+        <dt>
+            @Html.DisplayNameFor(model => model.Puzzle.MinutesOfEventLockout)
+        </dt>
+        <dd>
+            @Html.DisplayFor(model => model.Puzzle.MinutesOfEventLockout)
+        </dd>
         <dt>
             @Html.DisplayNameFor(model => model.Puzzle.MaxAnnotationKey)
         </dt>
diff --git a/ServerCore/Pages/Puzzles/Edit.cshtml b/ServerCore/Pages/Puzzles/Edit.cshtml
index a14596d5..7a7ca5a7 100644
--- a/ServerCore/Pages/Puzzles/Edit.cshtml
+++ b/ServerCore/Pages/Puzzles/Edit.cshtml
@@ -49,6 +49,13 @@
                     </label>
                 </div>
             </div>
+            <div class="form-group">
+                <div class="checkbox">
+                    <label>
+                        <input asp-for="Puzzle.IsCheatCode" /> @Html.DisplayNameFor(model => model.Puzzle.IsCheatCode)
+                    </label>
+                </div>
+            </div>
             <div class="form-group">
                 <label asp-for="Puzzle.SolveValue" class="control-label"></label>
                 <input asp-for="Puzzle.SolveValue" class="form-control" />
@@ -91,6 +98,11 @@
                 <input asp-for="Puzzle.MinutesToAutomaticallySolve" class="form-control" />
                 <span asp-validation-for="Puzzle.MinutesToAutomaticallySolve" class="text-danger"></span>
             </div>
+            <div class="form-group">
+                <label asp-for="Puzzle.MinutesOfEventLockout" class="control-label"></label>
+                <input asp-for="Puzzle.MinutesOfEventLockout" class="form-control" />
+                <span asp-validation-for="Puzzle.MinutesOfEventLockout" class="text-danger"></span>
+            </div>
             <div class="form-group">
                 <label asp-for="Puzzle.MaxAnnotationKey" class="control-label"></label>
                 <input asp-for="Puzzle.MaxAnnotationKey" class="form-control" />
diff --git a/ServerCore/Pages/Puzzles/Status.cshtml b/ServerCore/Pages/Puzzles/Status.cshtml
index e4b4da86..d3421482 100644
--- a/ServerCore/Pages/Puzzles/Status.cshtml
+++ b/ServerCore/Pages/Puzzles/Status.cshtml
@@ -16,17 +16,17 @@
     <thead>
         <tr>
             <th>
-                <a asp-page="./Status" asp-route-id="@Model.Puzzle.ID" asp-route-sort="@(Model.SortForColumnLink(StatusModel.SortOrder.TeamAscending, StatusModel.SortOrder.TeamDescending))">
+                <a asp-page="./Status" asp-route-puzzleId="@Model.Puzzle.ID" asp-route-sort="@(Model.SortForColumnLink(StatusModel.SortOrder.TeamAscending, StatusModel.SortOrder.TeamDescending))">
                     @Html.DisplayNameFor(model => model.PuzzleStatePerTeam[0].Team) @Html.DisplayNameFor(model => model.PuzzleStatePerTeam[0].Team.Name)
                 </a>
             </th>
             <th>
-                <a asp-page="./Status" asp-route-id="@Model.Puzzle.ID" asp-route-sort="@(Model.SortForColumnLink(StatusModel.SortOrder.UnlockAscending, StatusModel.SortOrder.UnlockDescending))">
+                <a asp-page="./Status" asp-route-puzzleId="@Model.Puzzle.ID" asp-route-sort="@(Model.SortForColumnLink(StatusModel.SortOrder.UnlockAscending, StatusModel.SortOrder.UnlockDescending))">
                     @Html.DisplayNameFor(model => model.PuzzleStatePerTeam[0].UnlockedTime)
                 </a>
             </th>
             <th>
-                <a asp-page="./Status" asp-route-id="@Model.Puzzle.ID" asp-route-sort="@(Model.SortForColumnLink(StatusModel.SortOrder.SolveAscending, StatusModel.SortOrder.SolveDescending))">
+                <a asp-page="./Status" asp-route-puzzleId="@Model.Puzzle.ID" asp-route-sort="@(Model.SortForColumnLink(StatusModel.SortOrder.SolveAscending, StatusModel.SortOrder.SolveDescending))">
                     @Html.DisplayNameFor(model => model.PuzzleStatePerTeam[0].SolvedTime)
                 </a>
             </th>
@@ -43,7 +43,7 @@
         {
             <tr>
                 <td>
-                    <a asp-page="../Teams/Status" asp-route-id="@item.Team.ID">@Html.DisplayFor(modelItem => item.Team.Name)</a>
+                    <a asp-page="../Teams/Status" asp-route-teamId="@item.Team.ID">@Html.DisplayFor(modelItem => item.Team.Name)</a>
                 </td>
                 <td>
                     @if (item.UnlockedTime == null)
diff --git a/ServerCore/Pages/Submissions/Index.cshtml b/ServerCore/Pages/Submissions/Index.cshtml
index 6735d32e..5d80da86 100644
--- a/ServerCore/Pages/Submissions/Index.cshtml
+++ b/ServerCore/Pages/Submissions/Index.cshtml
@@ -17,44 +17,50 @@
 <br />
 <div class="row">
     <div class="col-md-4">
-    @if (!string.IsNullOrEmpty(Model.AnswerToken))
-    {
-        <div class="alert alert-success" role="alert">
-            You got it! Correct answer: @Model.AnswerToken
-        </div>
-    }
-    else if (!@Model.Event.IsAnswerSubmissionActive)
-    {
-        <div class="col-md-12" style="padding-bottom: 15px;">
-            <h3>This event is not in session. No submissions will be accepted at this time.</h3>
-        </div>
-    }
-    else if (Model.PuzzleState.IsEmailOnlyMode)
-    {
-        <div class="alert alert-danger" role="alert">
-            You have submitted too many wrong responses. Please email your solutions to <a href="mailto:@(Model.PuzzleState?.Puzzle.SupportEmailAlias ?? (Model.Event?.ContactEmail ?? "puzzhunt@microsoft.com"))">@(Model.PuzzleState?.Puzzle.SupportEmailAlias ?? (Model.Event?.ContactEmail ?? "puzzhunt@microsoft.com"))</a>.
-        </div>
-    }
-    else if (Model.PuzzleState.IsTeamLockedOut)
-    {
-        <div class="alert alert-danger" role="alert">
-           You are locked out. Please wait <span id="LockoutTimer">@Model.PuzzleState.LockoutTimeRemaining.ToString(@"mm\:ss")</span> before attempting another submission.
-        </div>
-    }
-    else
-    {
-        <form method="post">
-            <div asp-validation-summary="ModelOnly" class="text-danger"></div>
-            <div class="form-group">
-                <label asp-for="Submission.SubmissionText" class="control-label">Answer</label>
-                <input asp-for="Submission.SubmissionText" class="form-control" />
-                <span asp-validation-for="Submission.SubmissionText" class="text-danger"></span>
+        @if (!string.IsNullOrEmpty(Model.AnswerToken))
+        {
+            <div class="alert alert-success" role="alert">
+                You got it! Correct answer: @Model.AnswerToken
             </div>
-            <div class="form-group">
-                <input type="submit" value="Submit" class="btn btn-default" />
+        }
+        else if (!@Model.Event.IsAnswerSubmissionActive)
+        {
+            <div class="col-md-12" style="padding-bottom: 15px;">
+                <h3>This event is not in session. No submissions will be accepted at this time.</h3>
             </div>
-        </form>
-    }
+        }
+        else if (Model.PuzzleState.IsEmailOnlyMode)
+        {
+            <div class="alert alert-danger" role="alert">
+                You have submitted too many wrong responses. Please email your solutions to <a href="mailto:@(Model.PuzzleState?.Puzzle.SupportEmailAlias ?? (Model.Event?.ContactEmail ?? "puzzhunt@microsoft.com"))">@(Model.PuzzleState?.Puzzle.SupportEmailAlias ?? (Model.Event?.ContactEmail ?? "puzzhunt@microsoft.com"))</a>.
+            </div>
+        }
+        else if (Model.PuzzleState.IsTeamLockedOut)
+        {
+            <div class="alert alert-danger" role="alert">
+                You are locked out. Please wait <span id="LockoutTimer">@Model.PuzzleState.LockoutTimeRemaining.ToString(@"mm\:ss")</span> before attempting another submission.
+            </div>
+        }
+        else if (Model.PuzzlesCausingGlobalLockout.Count != 0 && !Model.PuzzlesCausingGlobalLockout.Contains(Model.Puzzle))
+        {
+            <div class="alert alert-danger" role="alert">
+                You are in global lockout until time expires on '@Model.PuzzlesCausingGlobalLockout[0].Name', or it is solved. Go help your teammates with that puzzle!
+            </div>
+        }
+        else
+        {
+            <form method="post">
+                <div asp-validation-summary="ModelOnly" class="text-danger"></div>
+                <div class="form-group">
+                    <label asp-for="Submission.SubmissionText" class="control-label">Answer</label>
+                    <input asp-for="Submission.SubmissionText" class="form-control" />
+                    <span asp-validation-for="Submission.SubmissionText" class="text-danger"></span>
+                </div>
+                <div class="form-group">
+                    <input type="submit" value="Submit" class="btn btn-default" />
+                </div>
+            </form>
+        }
     </div>
 </div>
 
diff --git a/ServerCore/Pages/Submissions/Index.cshtml.cs b/ServerCore/Pages/Submissions/Index.cshtml.cs
index 4ed364ec..0d0b2ee4 100644
--- a/ServerCore/Pages/Submissions/Index.cshtml.cs
+++ b/ServerCore/Pages/Submissions/Index.cshtml.cs
@@ -33,6 +33,8 @@ public IndexModel(PuzzleServerContext serverContext, UserManager<IdentityUser> u
 
         public string AnswerToken { get; set; }
 
+        public IList<Puzzle> PuzzlesCausingGlobalLockout { get; set; }
+
         public async Task<IActionResult> OnPostAsync(int puzzleId, int teamId)
         {
             if (!this.Event.IsAnswerSubmissionActive)
@@ -168,6 +170,8 @@ private async Task SetupContext(int puzzleId, int teamId)
                        s.Puzzle.ID == puzzleId)
                 .OrderBy(submission => submission.TimeSubmitted)
                 .ToListAsync();
+
+            PuzzlesCausingGlobalLockout = await PuzzleStateHelper.PuzzlesCausingGlobalLockout(_context, Event, team).ToListAsync();
         }
 
         /// <summary>
diff --git a/ServerCore/Pages/Teams/Play.cshtml.cs b/ServerCore/Pages/Teams/Play.cshtml.cs
index 110f6d4d..8d4a20e5 100644
--- a/ServerCore/Pages/Teams/Play.cshtml.cs
+++ b/ServerCore/Pages/Teams/Play.cshtml.cs
@@ -48,6 +48,13 @@ public async Task OnGetAsync(SortOrder? sort)
             // all puzzles for this event that are real puzzles
             var puzzlesInEventQ = _context.Puzzles.Where(puzzle => puzzle.Event.ID == this.Event.ID && puzzle.IsPuzzle);
 
+            // unless we're in a global lockout, then filter to those!
+            var puzzlesCausingGlobalLockoutQ = PuzzleStateHelper.PuzzlesCausingGlobalLockout(_context, Event, myTeam);
+            if (await puzzlesCausingGlobalLockoutQ.AnyAsync())
+            {
+                puzzlesInEventQ = puzzlesCausingGlobalLockoutQ;
+            }
+
             // all puzzle states for this team that are unlocked (note: IsUnlocked bool is going to harm perf, just null check the time here)
             // Note that it's OK if some puzzles do not yet have a state record; those puzzles are clearly still locked and hence invisible.
             var stateForTeamQ = _context.PuzzleStatePerTeam.Where(state => state.TeamID == this.TeamID && state.UnlockedTime != null);
diff --git a/ServerCore/PuzzleStateHelper.cs b/ServerCore/PuzzleStateHelper.cs
index ffc41e35..d06b9931 100644
--- a/ServerCore/PuzzleStateHelper.cs
+++ b/ServerCore/PuzzleStateHelper.cs
@@ -185,7 +185,7 @@ public static async Task SetSolveStateAsync(
             }
 
             // Award hint coins
-            if (value != null && puzzle.HintCoinsForSolve != 0)
+            if (value != null && puzzle != null && puzzle.HintCoinsForSolve != 0)
             {
                 if (team != null)
                 {
@@ -340,6 +340,17 @@ public static async Task CheckForTimedUnlocksAsync(
             }
         }
 
+        public static IQueryable<Puzzle> PuzzlesCausingGlobalLockout(
+            PuzzleServerContext context, 
+            Event eventObj, 
+            Team team)
+        {
+            DateTime now = DateTime.UtcNow;
+            return PuzzleStateHelper.GetSparseQuery(context, eventObj, null, team)
+                .Where(state => state.SolvedTime == null && state.UnlockedTime != null && state.Puzzle.MinutesOfEventLockout != 0 && state.UnlockedTime.Value + TimeSpan.FromMinutes(state.Puzzle.MinutesOfEventLockout) > now)
+                .Select((s) => s.Puzzle);
+        }
+
         /// <summary>
         /// Get a writable query of puzzle state. In the course of constructing the query, it will instantiate any state records that are missing on the server.
         /// </summary>