diff --git a/folks/backend-store.vala b/folks/backend-store.vala
index b6aff32..d74848c 100644
--- a/folks/backend-store.vala
+++ b/folks/backend-store.vala
@@ -39,6 +39,8 @@ public class Folks.BackendStore : Object {
 
   private HashMap<string,Backend> backend_hash;
   private GLib.List<ModuleFinalizeFunc> finalize_funcs = null;
+  private static weak BackendStore instance;
+  private static bool backends_loaded = false;
 
   /**
    * Emitted when a backend has been added to the BackendStore.
@@ -46,14 +48,66 @@ public class Folks.BackendStore : Object {
    * This will not be emitted until after {@link BackendStore.load_backends}
    * has been called.
    *
+   * {@link Backend}s referenced in this signal are also included in @{link
+   * BackendStore.enabled_backends}.
+   *
    * @param backend the new {@link Backend}
    */
   public signal void backend_available (Backend backend);
 
   /**
+   * The list of backends visible to this store which have not been explicitly
+   * disabled.
+   *
+   * This list will be empty before {@link BackendStore.load_backends} has been
+   * called.
+   *
+   * The backends in this list have not necessarily been prepared (see {@link
+   * Backend.prepare}).
+   *
+   * These are the same backends that are exposed in the {@link
+   * BackendStore.backend_available} signal. However, the {@link BackendStore}
+   * may have emitted the signal before you access the @{link BackendStore}, so
+   * it's necessary to read this property in addition to connecting to the
+   * signal.
+   *
+   * @since 0.1.17
+   */
+  public GLib.List<Backend> enabled_backends
+    {
+      owned get
+        {
+          var backends = new GLib.List<Backend> ();
+          foreach (var entry in this.backend_hash)
+            {
+              backends.prepend (entry.value);
+
+            }
+
+          return backends;
+        }
+
+      private set {}
+    }
+
+  /**
    * Create a new BackendStore.
    */
-  public BackendStore ()
+  public static BackendStore dup ()
+    {
+      if (instance == null)
+        {
+          /* use an intermediate variable to force a strong reference */
+          var new_instance = new BackendStore ();
+          instance = new_instance;
+
+          return new_instance;
+        }
+
+      return instance;
+    }
+
+  private BackendStore ()
     {
       this.backend_hash = new HashMap<string,Backend> (str_hash, str_equal);
     }
@@ -63,6 +117,12 @@ public class Folks.BackendStore : Object {
       /* Finalize all the loaded modules */
       foreach (ModuleFinalizeFunc func in this.finalize_funcs)
         func (this);
+
+      /* reset status of backends */
+      this.backends_loaded = false;
+
+      /* manually clear the singleton instance */
+      instance = null;
     }
 
   /**
diff --git a/folks/individual-aggregator.vala b/folks/individual-aggregator.vala
index 26353cd..f6fb598 100644
--- a/folks/individual-aggregator.vala
+++ b/folks/individual-aggregator.vala
@@ -123,7 +123,7 @@ public class Folks.IndividualAggregator : Object
       this.linking_enabled = (disable_linking == null ||
           disable_linking == "no" || disable_linking == "0");
 
-      this.backend_store = new BackendStore ();
+      this.backend_store = BackendStore.dup ();
       this.backend_store.backend_available.connect (this.backend_available_cb);
     }
 
@@ -135,31 +135,53 @@ public class Folks.IndividualAggregator : Object
    * {@link IndividualAggregator.individuals_changed} signal, or a race
    * condition could occur, with the signal being emitted before your code has
    * connected to them, and {@link Individual}s getting "lost" as a result.
+   *
+   * Once this async function returns (ie, you have called its _finish()
+   * function if you're using this from C), all the {@link Backend}s will have
+   * been prepared (though no {@link PersonaStore}s are guaranteed to be
+   * available yet). This last guarantee is new as of version 0.1.17.
    */
   public async void prepare () throws GLib.Error
     {
       this.backend_store.load_backends ();
     }
 
-  private void backend_available_cb (BackendStore backend_store,
-      Backend backend)
+  private async void prepare_backend (Backend backend)
     {
-      backend.persona_store_added.connect (this.backend_persona_store_added_cb);
-      backend.persona_store_removed.connect (
-          this.backend_persona_store_removed_cb);
-
-      backend.prepare.begin ((obj, result) =>
+      if (!this.backends.contains (backend))
         {
+          /* ideally, we wouldn't add this backend until after it's been
+           * successfully prepared, but we need to prevent the backend from
+           * being prepared() multiple times (simultaneously) */
+          this.backends.add (backend);
+
+          backend.persona_store_added.connect (
+              this.backend_persona_store_added_cb);
+          backend.persona_store_removed.connect (
+              this.backend_persona_store_removed_cb);
+
           try
             {
-              backend.prepare.end (result);
+              yield backend.prepare ();
             }
           catch (GLib.Error e)
             {
               warning ("Error preparing Backend '%s': %s", backend.name,
                   e.message);
+
+              backend.persona_store_added.disconnect (
+                  this.backend_persona_store_added_cb);
+              backend.persona_store_removed.disconnect (
+                  this.backend_persona_store_removed_cb);
+              this.backends.remove (backend);
             }
-        });
+        }
+    }
+
+  private void backend_available_cb (BackendStore backend_store,
+      Backend backend)
+    {
+      this.prepare_backend.begin (backend);
     }
 
   private void backend_persona_store_added_cb (Backend backend,
diff --git a/tools/import.vala b/tools/import.vala
index aca2a97..451290f 100644
--- a/tools/import.vala
+++ b/tools/import.vala
@@ -90,7 +90,7 @@ public class Folks.ImportTool : Object
 
   private static async bool import ()
     {
-      BackendStore backend_store = new BackendStore ();
+      BackendStore backend_store = BackendStore.dup ();
 
       try
         {
