                                                   service
                                                   request-shutdown)
                            job-pool))
-            (when (pos? gc-interval-millis)
-              (let [request (db-config->clean-request database)]
-                (interspaced gc-interval-millis
-                             #(coordinate-gc-with-shutdown write-db clean-lock
-                                                           database request
-                                                           (:stop-status context))
-                             job-pool)))
+            (mapv (fn [cfg db]
+                    (let [interval (to-millis (:gc-interval cfg))]
+                      (when (pos? interval)
+                        (let [request (db-config->clean-request cfg)]
+                          (interspaced interval
+                                       #(coordinate-gc-with-shutdown db clean-lock
+                                                                     cfg request
+                                                                     (:stop-status context))
+                                       job-pool)))))
+                  write-cfgs
+                  write-dbs)
             (-> context
                 (assoc :job-pool job-pool
                        :command-loader command-loader)

  (close-write-dbs (get-in context [:shared-globals :scf-write-dbs]))
  (when-let [ds (get-in context [:shared-globals :scf-read-db :datasource])]
    (.close ^Closeable ds))
  (when-let [command-loader (:command-loader context)]
    (future-cancel command-loader))
  context)


          ;; Pretty much this helper just knows our job-pool and gc-interval
          (let [job-pool (mk-pool)
                ;; FIXME: forbid subdb settings?
                schema-check-interval (:schema-check-interval database)
                write-cfgs (conf/reduce-section
                            (fn [result name settings] (conj result settings))
