diff --git a/android/app/src/main/java/io/v/syncslides/DeckChooserActivity.java b/android/app/src/main/java/io/v/syncslides/DeckChooserActivity.java
index dba60e0..c866ec1 100644
--- a/android/app/src/main/java/io/v/syncslides/DeckChooserActivity.java
+++ b/android/app/src/main/java/io/v/syncslides/DeckChooserActivity.java
@@ -11,6 +11,7 @@
 import android.support.v7.app.AppCompatActivity;
 import android.util.Log;
 import android.view.Menu;
+import android.widget.Toast;
 
 import io.v.syncslides.V23;
 
@@ -29,7 +30,13 @@
         super.onCreate(savedInstanceState);
         // Immediately initialize V23, possibly sending user to the
         // AccountManager to get blessings.
-        V23.Singleton.get().init(getApplicationContext(), this);
+        try {
+            V23.Singleton.get().init(getApplicationContext(), this);
+        } catch (InitException e) {
+            // TODO(kash): Start a to-be-written SettingsActivity that makes it possible
+            // to wipe the state of syncbase and/or blessings.
+            handleError("Failed to init", e);
+        }
 
         setContentView(R.layout.activity_deck_chooser);
 
@@ -79,12 +86,21 @@
     @Override
     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
         super.onActivityResult(requestCode, resultCode, data);
-        Log.d(TAG, "onActivityResult");
-        if (V23.Singleton.get().onActivityResult(
-                getApplicationContext(), requestCode, resultCode, data)) {
-            Log.d(TAG, "did the v23 result");
-            return;
+        try {
+            if (V23.Singleton.get().onActivityResult(
+                    getApplicationContext(), requestCode, resultCode, data)) {
+                return;
+            }
+        } catch (InitException e) {
+            // TODO(kash): Start a to-be-written SettingsActivity that makes it possible
+            // to wipe the state of syncbase and/or blessings.
+            handleError("Failed onActivityResult initialization", e);
         }
         // Any other activity results would be handled here.
     }
+
+    private void handleError(String msg, Throwable throwable) {
+        Log.e(TAG, msg + ": " + Log.getStackTraceString(throwable));
+        Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_SHORT).show();
+    }
 }
diff --git a/android/app/src/main/java/io/v/syncslides/InitException.java b/android/app/src/main/java/io/v/syncslides/InitException.java
new file mode 100644
index 0000000..3fd2038
--- /dev/null
+++ b/android/app/src/main/java/io/v/syncslides/InitException.java
@@ -0,0 +1,18 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.syncslides;
+
+/**
+ * Thrown when initialization fails.
+ */
+public class InitException extends Exception {
+    public InitException(Throwable throwable) {
+        super(throwable);
+    }
+
+    public InitException(String detailMessage, Throwable throwable) {
+        super(detailMessage, throwable);
+    }
+}
diff --git a/android/app/src/main/java/io/v/syncslides/V23.java b/android/app/src/main/java/io/v/syncslides/V23.java
index 1a8ab37..4c9b5d7 100644
--- a/android/app/src/main/java/io/v/syncslides/V23.java
+++ b/android/app/src/main/java/io/v/syncslides/V23.java
@@ -13,6 +13,7 @@
 import io.v.android.v23.V;
 import io.v.android.v23.services.blessing.BlessingCreationException;
 import io.v.android.v23.services.blessing.BlessingService;
+import io.v.syncslides.db.DB;
 import io.v.v23.context.VContext;
 import io.v.v23.security.BlessingPattern;
 import io.v.v23.security.Blessings;
@@ -53,7 +54,7 @@
     private V23() {
     }
 
-    public void init(Context context, Activity activity) {
+    public void init(Context context, Activity activity) throws InitException {
         if (mBlessings != null) {
             return;
         }
@@ -72,16 +73,18 @@
 
     /**
      * To be called from an Activity's onActivityResult method, e.g.
-     *     public void onActivityResult(
-     *         int requestCode, int resultCode, Intent data) {
-     *         if (V23.Singleton.get().onActivityResult(
-     *             getApplicationContext(), requestCode, resultCode, data)) {
-     *           return;
+     *     public void onActivityResult(int requestCode, int resultCode, Intent data) {
+     *         try {
+     *             if (V23.Singleton.get().onActivityResult(
+     *                     getApplicationContext(), requestCode, resultCode, data)) {
+     *               return;
+     *             }
+     *         } catch (InitException e) {
+     *             // Handle the error, possibly by resetting blessings and syncbase.
      *         }
-     *     }
      */
     public boolean onActivityResult(
-            Context context, int requestCode, int resultCode, Intent data) {
+            Context context, int requestCode, int resultCode, Intent data) throws InitException {
         if (requestCode != BLESSING_REQUEST) {
             return false;
         }
@@ -91,37 +94,65 @@
             Blessings blessings = (Blessings) VomUtil.decode(blessingsVom, Blessings.class);
             BlessingsManager.addBlessings(mContext, blessings);
             configurePrincipal(blessings);
-//            DB.Singleton.get(androidCtx).init();
         } catch (BlessingCreationException e) {
-            throw new IllegalStateException(e);
+            throw new InitException(e);
         } catch (VException e) {
-            throw new IllegalStateException(e);
+            throw new InitException(e);
         }
         return true;
     }
 
-    private Blessings loadBlessings() {
+    private Blessings loadBlessings() throws InitException {
         try {
             // See if there are blessings stored in shared preferences.
             return BlessingsManager.getBlessings(mContext);
         } catch (VException e) {
-            Log.w(TAG, "Cannot get blessings from prefs: " + e.getMessage());
+            throw new InitException(e);
         }
-        return null;
     }
 
-    private void configurePrincipal(Blessings blessings) {
+    private void configurePrincipal(Blessings blessings) throws InitException {
         try {
             VPrincipal p = V.getPrincipal(mVContext);
             p.blessingStore().setDefaultBlessings(blessings);
             p.blessingStore().set(blessings, new BlessingPattern("..."));
             VSecurity.addToRoots(p, blessings);
             mBlessings = blessings;
+            DB.Singleton.get().init(mContext);
         } catch (VException e) {
-            Log.e(TAG, String.format(
-                    "Couldn't set local blessing %s: %s", blessings, e.getMessage()));
+            throw new InitException(
+                    String.format("Couldn't set local blessing %s", blessings), e);
         }
     }
 
+    /**
+     * v23 operations that require a blessing (almost everything) will fail if
+     * attempted before this is true.
+     *
+     * The simplest usage is 1) There are no blessings. 2) An activity starts
+     * and calls V23Manager.init. 2) init notices there are no blessings and
+     * calls startActivityForResult 3) meanwhile, the activity and/or its
+     * components still run, but can test isBlessed before attempting anything
+     * requiring blessings. The activity will soon be re-initialized anyway. 4)
+     * user kicked over into 'account manager', gets a blessing, and the
+     * activity is restarted, this time with isBlessed == true.
+     */
+    public boolean isBlessed() {
+        return mBlessings != null;
+    }
+
+    /**
+     * Returns the blessings for this process.
+     */
+    public Blessings getBlessings() {
+        return mBlessings;
+    }
+
+    /**
+     * Returns the Vanadium context for this process.
+     */
+    public VContext getVContext() {
+        return mVContext;
+    }
 
 }
diff --git a/android/app/src/main/java/io/v/syncslides/db/DB.java b/android/app/src/main/java/io/v/syncslides/db/DB.java
new file mode 100644
index 0000000..8281671
--- /dev/null
+++ b/android/app/src/main/java/io/v/syncslides/db/DB.java
@@ -0,0 +1,39 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.syncslides.db;
+
+import android.content.Context;
+
+import io.v.syncslides.InitException;
+import io.v.syncslides.model.Deck;
+import io.v.syncslides.model.DynamicList;
+
+/**
+ * Provides high-level methods for getting and setting the state of SyncSlides.
+ * It is an interface instead of a concrete class to make testing easier.
+ */
+public interface DB {
+    class Singleton {
+        private static volatile DB instance;
+
+        public static DB get() {
+            DB result = instance;
+            if (instance == null) {
+                synchronized (Singleton.class) {
+                    result = instance;
+                    if (result == null) {
+                        instance = result = new SyncbaseDB();
+                    }
+                }
+            }
+            return result;
+        }
+    }
+
+    /**
+     * Perform initialization steps.
+     */
+    void init(Context context) throws InitException;
+}
diff --git a/android/app/src/main/java/io/v/syncslides/db/SyncbaseDB.java b/android/app/src/main/java/io/v/syncslides/db/SyncbaseDB.java
new file mode 100644
index 0000000..8ad5fce
--- /dev/null
+++ b/android/app/src/main/java/io/v/syncslides/db/SyncbaseDB.java
@@ -0,0 +1,146 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package io.v.syncslides.db;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.provider.Settings;
+import android.util.Log;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import java.io.File;
+import java.util.Arrays;
+
+import io.v.android.v23.V;
+import io.v.impl.google.services.syncbase.SyncbaseServer;
+import io.v.syncslides.InitException;
+import io.v.syncslides.V23;
+import io.v.syncslides.model.Deck;
+import io.v.syncslides.model.DynamicList;
+import io.v.v23.context.VContext;
+import io.v.v23.rpc.Server;
+import io.v.v23.security.BlessingPattern;
+import io.v.v23.security.Blessings;
+import io.v.v23.security.access.AccessList;
+import io.v.v23.security.access.Constants;
+import io.v.v23.security.access.Permissions;
+import io.v.v23.syncbase.Syncbase;
+import io.v.v23.syncbase.SyncbaseApp;
+import io.v.v23.syncbase.SyncbaseService;
+import io.v.v23.syncbase.nosql.Database;
+import io.v.v23.syncbase.nosql.Table;
+import io.v.v23.verror.VException;
+
+public class SyncbaseDB implements DB {
+    private static final String TAG = "SyncbaseDB";
+    private static final String SYNCBASE_APP = "syncslides";
+    private static final String SYNCBASE_DB = "syncslides";
+    private static final String DECKS_TABLE = "Decks";
+    private static final String NOTES_TABLE = "Notes";
+    static final String PRESENTATIONS_TABLE = "Presentations";
+    static final String CURRENT_SLIDE = "CurrentSlide";
+    static final String QUESTIONS = "questions";
+    private static final String SYNCGROUP_PRESENTATION_DESCRIPTION = "Live Presentation";
+
+    private boolean mInitialized = false;
+    private Handler mHandler;
+    private Permissions mPermissions;
+    private Context mContext;
+    private VContext mVContext;
+    private Server mSyncbaseServer;
+    private Database mDB;
+
+    // Singleton.
+    SyncbaseDB() {
+    }
+
+    @Override
+    public void init(Context context) throws InitException {
+        if (mInitialized) {
+            return;
+        }
+        mContext = context;
+        mHandler = new Handler(Looper.getMainLooper());
+
+        // If blessings aren't in place, the fragment that called this
+        // initialization may continue to load and use DB, but nothing will
+        // work so DB methods should return noop values.  It's assumed that
+        // the calling fragment will send the user to the AccountManager,
+        // accept blessings on return, then re-call this init.
+        if (!V23.Singleton.get().isBlessed()) {
+            Log.d(TAG, "no blessings.");
+            return;
+        }
+        mVContext = V23.Singleton.get().getVContext();
+        setupSyncbase();
+    }
+
+    // TODO(kash): Run this in an AsyncTask so it doesn't block the UI.
+    private void setupSyncbase() throws InitException {
+        Blessings blessings = V23.Singleton.get().getBlessings();
+        AccessList everyoneAcl = new AccessList(
+                ImmutableList.of(new BlessingPattern("...")), ImmutableList.<String>of());
+        AccessList justMeAcl = new AccessList(
+                ImmutableList.of(new BlessingPattern(blessings.toString())),
+                ImmutableList.<String>of());
+
+        mPermissions = new Permissions(ImmutableMap.of(
+                Constants.RESOLVE.getValue(), everyoneAcl,
+                Constants.READ.getValue(), justMeAcl,
+                Constants.WRITE.getValue(), justMeAcl,
+                Constants.ADMIN.getValue(), justMeAcl));
+
+        // Prepare the syncbase storage directory.
+        File storageDir = new File(mContext.getFilesDir(), "syncbase");
+        storageDir.mkdirs();
+
+        try {
+            String id = Settings.Secure.getString(
+                    mContext.getContentResolver(), Settings.Secure.ANDROID_ID);
+            mVContext = SyncbaseServer.withNewServer(mVContext, new SyncbaseServer.Params()
+                    .withPermissions(mPermissions)
+                            // TODO(kash): Mount it!
+                            //.withName(V23Manager.syncName(id))
+                    .withStorageRootDir(storageDir.getAbsolutePath()));
+        } catch (SyncbaseServer.StartException e) {
+            throw new InitException("Couldn't start syncbase server", e);
+        }
+        try {
+            mSyncbaseServer = V.getServer(mVContext);
+            Log.i(TAG, "Endpoints: " + Arrays.toString(mSyncbaseServer.getStatus().getEndpoints()));
+            String serverName = "/" + mSyncbaseServer.getStatus().getEndpoints()[0];
+
+            // Now that we've started Syncbase, set up our connections to it.
+            SyncbaseService service = Syncbase.newService(serverName);
+            SyncbaseApp app = service.getApp(SYNCBASE_APP);
+            if (!app.exists(mVContext)) {
+                app.create(mVContext, mPermissions);
+            }
+            mDB = app.getNoSqlDatabase(SYNCBASE_DB, null);
+            if (!mDB.exists(mVContext)) {
+                mDB.create(mVContext, mPermissions);
+            }
+            Table decks = mDB.getTable(DECKS_TABLE);
+            if (!decks.exists(mVContext)) {
+                decks.create(mVContext, mPermissions);
+            }
+            Table notes = mDB.getTable(NOTES_TABLE);
+            if (!notes.exists(mVContext)) {
+                notes.create(mVContext, mPermissions);
+            }
+            Table presentations = mDB.getTable(PRESENTATIONS_TABLE);
+            if (!presentations.exists(mVContext)) {
+                presentations.create(mVContext, mPermissions);
+            }
+            //importDecks();
+        } catch (VException e) {
+            throw new InitException("Couldn't setup syncbase service", e);
+        }
+        mInitialized = true;
+    }
+}