diff --git a/services/groups/groupsd/main.go b/services/groups/groupsd/main.go
index f37c64a..a1ef298 100644
--- a/services/groups/groupsd/main.go
+++ b/services/groups/groupsd/main.go
@@ -23,7 +23,7 @@
 	"v.io/x/ref/lib/xrpc"
 	_ "v.io/x/ref/runtime/factories/roaming"
 	"v.io/x/ref/services/groups/internal/server"
-	"v.io/x/ref/services/groups/internal/store/memstore"
+	"v.io/x/ref/services/groups/internal/store/mem"
 )
 
 var flagName string
@@ -68,7 +68,7 @@
 		ctx.Infof("No permissions flag provided. Giving local principal all permissions.")
 		perms = defaultPerms(security.DefaultBlessingPatterns(v23.GetPrincipal(ctx)))
 	}
-	m := server.NewManager(memstore.New(), perms)
+	m := server.NewManager(mem.New(), perms)
 	server, err := xrpc.NewDispatchingServer(ctx, flagName, m)
 	if err != nil {
 		fmt.Errorf("NewDispatchingServer(%v) failed: %v", flagName, err)
diff --git a/services/groups/internal/server/server_test.go b/services/groups/internal/server/server_test.go
index 11d81b1..1a68b70 100644
--- a/services/groups/internal/server/server_test.go
+++ b/services/groups/internal/server/server_test.go
@@ -23,10 +23,19 @@
 	"v.io/x/ref/services/groups/internal/server"
 	"v.io/x/ref/services/groups/internal/store"
 	"v.io/x/ref/services/groups/internal/store/gkv"
-	"v.io/x/ref/services/groups/internal/store/memstore"
+	"v.io/x/ref/services/groups/internal/store/leveldb"
+	"v.io/x/ref/services/groups/internal/store/mem"
 	"v.io/x/ref/test/testutil"
 )
 
+type backend int
+
+const (
+	gkvstore backend = iota
+	leveldbstore
+	memstore
+)
+
 func Fatal(t *testing.T, args ...interface{}) {
 	debug.PrintStack()
 	t.Fatal(args...)
@@ -89,20 +98,18 @@
 	return reflect.DeepEqual(a, b)
 }
 
-// TODO(sadovsky): Write storage engine tests, then maybe drop this constant.
-const useMemstore = false
-
-func newServer(ctx *context.T) (string, func()) {
+func newServer(ctx *context.T, be backend) (string, func()) {
 	// TODO(sadovsky): Pass in perms and test perms-checking in Group.Create().
 	perms := access.Permissions{}
 	var st store.Store
-	var file *os.File
+	var path string
 	var err error
 
-	if useMemstore {
-		st = memstore.New()
-	} else {
-		file, err = ioutil.TempFile("", "")
+	switch be {
+	case memstore:
+		st = mem.New()
+	case gkvstore:
+		file, err := ioutil.TempFile("", "")
 		if err != nil {
 			ctx.Fatal("ioutil.TempFile() failed: ", err)
 		}
@@ -110,6 +117,18 @@
 		if err != nil {
 			ctx.Fatal("gkv.New() failed: ", err)
 		}
+		path = file.Name()
+	case leveldbstore:
+		path, err = ioutil.TempDir("", "")
+		if err != nil {
+			ctx.Fatal("ioutil.TempDir() failed: ", err)
+		}
+		st, err = leveldb.Open(path)
+		if err != nil {
+			ctx.Fatal("leveldb.Open() failed: ", err)
+		}
+	default:
+		ctx.Fatal("unknown backend: ", be)
 	}
 
 	m := server.NewManager(st, perms)
@@ -122,13 +141,13 @@
 	name := server.Status().Endpoints[0].Name()
 	return name, func() {
 		server.Stop()
-		if file != nil {
-			os.Remove(file.Name())
+		if path != "" {
+			os.RemoveAll(path)
 		}
 	}
 }
 
-func setupOrDie() (clientCtx *context.T, serverName string, cleanup func()) {
+func setupOrDie(be backend) (clientCtx *context.T, serverName string, cleanup func()) {
 	ctx, shutdown := v23.Init()
 	cp, sp := testutil.NewPrincipal("client"), testutil.NewPrincipal("server")
 
@@ -156,7 +175,7 @@
 		clientCtx.Fatal("v23.WithPrincipal() failed: ", err)
 	}
 
-	serverName, stopServer := newServer(serverCtx)
+	serverName, stopServer := newServer(serverCtx, be)
 	cleanup = func() {
 		stopServer()
 		shutdown()
@@ -167,8 +186,20 @@
 ////////////////////////////////////////
 // Test cases
 
-func TestCreate(t *testing.T) {
-	ctx, serverName, cleanup := setupOrDie()
+func TestCreateGkvStore(t *testing.T) {
+	testCreateHelper(t, gkvstore)
+}
+
+func TestCreateLevelDBStore(t *testing.T) {
+	testCreateHelper(t, leveldbstore)
+}
+
+func TestCreateMemStore(t *testing.T) {
+	testCreateHelper(t, memstore)
+}
+
+func testCreateHelper(t *testing.T, be backend) {
+	ctx, serverName, cleanup := setupOrDie(be)
 	defer cleanup()
 
 	// Create a group with a default perms and no entries.
@@ -219,8 +250,20 @@
 	}
 }
 
-func TestDelete(t *testing.T) {
-	ctx, serverName, cleanup := setupOrDie()
+func TestDeleteGkvStore(t *testing.T) {
+	testDeleteHelper(t, gkvstore)
+}
+
+func TestDeleteLevelDBStore(t *testing.T) {
+	testDeleteHelper(t, leveldbstore)
+}
+
+func TestDeleteMemStore(t *testing.T) {
+	testDeleteHelper(t, memstore)
+}
+
+func testDeleteHelper(t *testing.T, be backend) {
+	ctx, serverName, cleanup := setupOrDie(be)
 	defer cleanup()
 
 	// Create a group with a default perms and no entries, check that we can
@@ -279,8 +322,20 @@
 	}
 }
 
-func TestPerms(t *testing.T) {
-	ctx, serverName, cleanup := setupOrDie()
+func TestPermsGkvStore(t *testing.T) {
+	testPermsHelper(t, gkvstore)
+}
+
+func TestPermsLevelDBStore(t *testing.T) {
+	testPermsHelper(t, leveldbstore)
+}
+
+func TestPermsMemStore(t *testing.T) {
+	testPermsHelper(t, memstore)
+}
+
+func testPermsHelper(t *testing.T, be backend) {
+	ctx, serverName, cleanup := setupOrDie(be)
 	defer cleanup()
 
 	// Create a group with a default perms.
@@ -384,9 +439,21 @@
 	}
 }
 
-// Mirrors TestRemove.
-func TestAdd(t *testing.T) {
-	ctx, serverName, cleanup := setupOrDie()
+func TestAddGkvStore(t *testing.T) {
+	testAddHelper(t, gkvstore)
+}
+
+func TestAddLevelDBStore(t *testing.T) {
+	testAddHelper(t, leveldbstore)
+}
+
+func TestAddMemStore(t *testing.T) {
+	testAddHelper(t, memstore)
+}
+
+// testAddHelper tests mirror testRemoveHelper tests.
+func testAddHelper(t *testing.T, be backend) {
+	ctx, serverName, cleanup := setupOrDie(be)
 	defer cleanup()
 
 	// Create a group with a default perms and no entries.
@@ -469,9 +536,21 @@
 	}
 }
 
-// Mirrors TestAdd.
-func TestRemove(t *testing.T) {
-	ctx, serverName, cleanup := setupOrDie()
+func TestRemoveGkvStore(t *testing.T) {
+	testRemoveHelper(t, gkvstore)
+}
+
+func TestRemoveLevelDBStore(t *testing.T) {
+	testRemoveHelper(t, leveldbstore)
+}
+
+func TestRemoveMemStore(t *testing.T) {
+	testRemoveHelper(t, memstore)
+}
+
+// testRemoveHelper tests mirror testAddHelper tests.
+func testRemoveHelper(t *testing.T, be backend) {
+	ctx, serverName, cleanup := setupOrDie(be)
 	defer cleanup()
 
 	// Create a group with a default perms and two entries.
diff --git a/services/groups/internal/store/leveldb/store.go b/services/groups/internal/store/leveldb/store.go
new file mode 100644
index 0000000..5f38f52
--- /dev/null
+++ b/services/groups/internal/store/leveldb/store.go
@@ -0,0 +1,134 @@
+// 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 leveldb provides an implementation of the groups server
+// Store interface that uses the levelDB-based syncbase storage layer.
+package leveldb
+
+import (
+	"strconv"
+
+	istore "v.io/syncbase/x/ref/services/syncbase/store"
+	"v.io/syncbase/x/ref/services/syncbase/store/leveldb"
+	"v.io/v23/vdl"
+	"v.io/v23/verror"
+	"v.io/v23/vom"
+	"v.io/x/ref/services/groups/internal/store"
+)
+
+type entry struct {
+	Value   interface{}
+	Version uint64
+}
+
+type T struct {
+	db istore.Store
+}
+
+var _ store.Store = (*T)(nil)
+
+// Open opens a groups server store located at the given path,
+// creating it if it doesn't exist.
+func Open(path string) (store.Store, error) {
+	db, err := leveldb.Open(path)
+	if err != nil {
+		return nil, convertError(err)
+	}
+	return &T{db: db}, nil
+}
+
+func (st *T) Get(key string, valbuf interface{}) (version string, err error) {
+	e, err := get(st.db, key)
+	if err != nil {
+		return "", err
+	}
+	if err := vdl.Convert(valbuf, e.Value); err != nil {
+		return "", convertError(err)
+	}
+	return strconv.FormatUint(e.Version, 10), nil
+}
+
+func (st *T) Insert(key string, value interface{}) error {
+	return istore.RunInTransaction(st.db, func(db istore.StoreReadWriter) error {
+		if _, err := get(db, key); verror.ErrorID(err) != store.ErrUnknownKey.ID {
+			if err != nil {
+				return err
+			}
+			return verror.New(store.ErrKeyExists, nil, key)
+		}
+		return put(db, key, &entry{Value: value})
+	})
+}
+
+func (st *T) Update(key string, value interface{}, version string) error {
+	return istore.RunInTransaction(st.db, func(db istore.StoreReadWriter) error {
+		e, err := get(db, key)
+		if err != nil {
+			return err
+		}
+		if err := e.checkVersion(version); err != nil {
+			return err
+		}
+		return put(db, key, &entry{Value: value, Version: e.Version + 1})
+	})
+}
+
+func (st *T) Delete(key string, version string) error {
+	return istore.RunInTransaction(st.db, func(db istore.StoreReadWriter) error {
+		e, err := get(db, key)
+		if err != nil {
+			return err
+		}
+		if err := e.checkVersion(version); err != nil {
+			return err
+		}
+		return delete(db, key)
+	})
+}
+
+func (st *T) Close() error {
+	return convertError(st.db.Close())
+}
+
+func get(db istore.StoreReadWriter, key string) (*entry, error) {
+	bytes, _ := db.Get([]byte(key), nil)
+	if bytes == nil {
+		return nil, verror.New(store.ErrUnknownKey, nil, key)
+	}
+	e := &entry{}
+	if err := vom.Decode(bytes, e); err != nil {
+		return nil, convertError(err)
+	}
+	return e, nil
+}
+
+func put(db istore.StoreReadWriter, key string, e *entry) error {
+	bytes, err := vom.Encode(e)
+	if err != nil {
+		return convertError(err)
+	}
+	if err := db.Put([]byte(key), bytes); err != nil {
+		return convertError(err)
+	}
+	return nil
+}
+
+func delete(db istore.StoreReadWriter, key string) error {
+	if err := db.Delete([]byte(key)); err != nil {
+		return convertError(err)
+	}
+	return nil
+}
+
+func (e *entry) checkVersion(version string) error {
+	newVersion := strconv.FormatUint(e.Version, 10)
+	if version != newVersion {
+		return verror.NewErrBadVersion(nil)
+	}
+	return nil
+}
+
+func convertError(err error) error {
+	return verror.Convert(verror.IDAction{}, nil, err)
+}
diff --git a/services/groups/internal/store/memstore/store.go b/services/groups/internal/store/mem/store.go
similarity index 92%
rename from services/groups/internal/store/memstore/store.go
rename to services/groups/internal/store/mem/store.go
index c086c44..f8ddd49 100644
--- a/services/groups/internal/store/memstore/store.go
+++ b/services/groups/internal/store/mem/store.go
@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package memstore provides a simple, in-memory implementation of server.Store.
-// Since it's a prototype implementation, it doesn't bother with entry-level
-// locking.
-package memstore
+// Package mem provides a simple, in-memory implementation of
+// server.Store. Since it's a prototype implementation, it doesn't
+// bother with entry-level locking.
+package mem
 
 import (
 	"strconv"