diff --git a/server/src/instance.rs b/server/src/instance.rs
index d6a76c7a..e814aa3d 100644
--- a/server/src/instance.rs
+++ b/server/src/instance.rs
@@ -17,7 +17,7 @@ use events::{EventsTx, Event};
 use player::{Player, Score, player_create};
 use construct::{Construct, construct_get};
 use mob::{bot_player, instance_mobs};
-use game::{Game, Phase, game_get, game_write};
+use game::{Game, Phase, game_get, game_write, game_update};
 use item::{Item};
 use rpc::{RpcMessage};
 use img;
@@ -51,7 +51,7 @@ pub enum TimeControl {
 impl TimeControl {
     fn vbox_time_seconds(&self) -> i64 {
         match self {
-            TimeControl::Standard => 180,
+            TimeControl::Standard => 10,
             TimeControl::Slow => 240,
             TimeControl::Practice => panic!("practice vbox seconds called"),
         }
@@ -59,7 +59,7 @@ impl TimeControl {
 
     fn game_time_seconds(&self) -> i64 {
         match self {
-            TimeControl::Standard => 60,
+            TimeControl::Standard => 10,
             TimeControl::Slow => 120,
             TimeControl::Practice => panic!("practice game seconds called"),
         }
@@ -139,28 +139,30 @@ impl Instance {
             .collect::<Vec<Uuid>>()
     }
 
-    pub fn upkeep(mut self) -> (Instance, Vec<Game>) {
+    pub fn upkeep(mut self) -> (Instance, Option<Game>) {
         // time out lobbies that have been open too long
         if self.phase == InstancePhase::Lobby && self.phase_timed_out() {
             self.finish();
-            return (self, vec![]);
+            return (self, None);
         }
 
         if self.phase != InstancePhase::InProgress {
-            return (self, vec![]);
+            return (self, None);
         }
 
         if !self.phase_timed_out() {
-            return (self, vec![]);
+            return (self, None);
         }
 
-        let new_games = self
+        let new_game = self
             .timed_out_players()
             .iter()
             .filter_map(|p| self.player_ready(*p).unwrap())
-            .collect::<Vec<Game>>();
+            .collect::<Vec<Game>>()
+            .into_iter()
+            .next();
 
-        (self, new_games)
+        (self, new_game)
     }
 
     fn set_name(mut self, name: String) -> Result<Instance, Error> {
@@ -731,6 +733,10 @@ pub fn instance_ready(tx: &mut Transaction, account: &Account, instance_id: Uuid
 
     if let Some(game) = instance.player_ready(player_id)? {
         game_write(tx, &game)?;
+
+        // ensures cleanup for warden etc is done
+        game_update(tx, &game)?;
+
         instance_update(tx, instance)?;
         return Ok(RpcMessage::GameState(game));
     }
@@ -862,12 +868,12 @@ mod tests {
 
         let (mut instance, new_games) = instance.upkeep();
 
-        assert_eq!(new_games.len(), 1);
+        assert!(new_games.is_some());
 
-        let game = &new_games[0];
+        let game = new_games.unwrap();
         assert!(game.finished());
 
-        instance.game_finished(game).unwrap();
+        instance.game_finished(&game).unwrap();
 
         assert_eq!(instance.rounds.len(), 2);
         assert!(instance.players.iter().all(|p| !p.ready));
diff --git a/server/src/warden.rs b/server/src/warden.rs
index 8232282a..9d58e678 100644
--- a/server/src/warden.rs
+++ b/server/src/warden.rs
@@ -131,11 +131,16 @@ fn fetch_games(mut tx: Transaction) -> Result<Transaction, Error> {
 
 fn fetch_instances(mut tx: Transaction) -> Result<Transaction, Error> {
     for mut instance in instances_need_upkeep(&mut tx)? {
-        let (instance, new_games) = instance.upkeep();
-        for game in new_games {
+        let (instance, new_game) = instance.upkeep();
+
+        if let Some(game) = new_game {
             game_write(&mut tx, &game)?;
+            instance_update(&mut tx, instance)?;
+            // ensures cleanup for forfeits etc is done
+            game_update(&mut tx, &game)?;
+        } else {
+            instance_update(&mut tx, instance)?;
         }
-        instance_update(&mut tx, instance)?;
     }
 
     for mut instance in instances_idle(&mut tx)? {