diff --git a/README.md b/README.md
index a1d96263..70bf5a55 100644
--- a/README.md
+++ b/README.md
@@ -145,7 +145,7 @@ configuration.
 Create a **DMap** object to access the cluster:
 
 ```go
-dm := db.NewDMap("my-dmap")
+dm, err := db.NewDMap("my-dmap")
 ```
 
 DMap object has *Put*, *PutEx*, *Get*, *Delete*, *LockWithTimeout*, *Unlock* and *Destroy* methods to access and modify data in Olric. 
@@ -492,7 +492,10 @@ func main() {
 	}()
 
 	// Put 10 items into the DMap object.
-	dm := db.NewDMap("bucket-of-arbitrary-items")
+	dm, err := db.NewDMap("bucket-of-arbitrary-items")
+	if err != nil {
+		log.Fatalf("Failed to call Start: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		c := customType{}
 		c.Field1 = fmt.Sprintf("num: %d", i)
diff --git a/client/client_test.go b/client/client_test.go
index 9b22bd13..ec351605 100644
--- a/client/client_test.go
+++ b/client/client_test.go
@@ -99,7 +99,10 @@ func TestClient_Get(t *testing.T) {
 	}
 
 	name := "mymap"
-	dm := db.NewDMap(name)
+	dm, err := db.NewDMap(name)
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	key, value := "my-key", "my-value"
 	err = dm.Put(key, value)
 	if err != nil {
@@ -139,7 +142,10 @@ func TestClient_Put(t *testing.T) {
 		t.Fatalf("Expected nil. Got: %v", err)
 	}
 
-	dm := db.NewDMap(name)
+	dm, err := db.NewDMap(name)
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	val, err := dm.Get(key)
 	if err != nil {
 		t.Fatalf("Expected nil. Got: %v", err)
@@ -176,7 +182,10 @@ func TestClient_PutEx(t *testing.T) {
 
 	// Wait for updating currentUnixNano in Olric.
 	time.Sleep(100 * time.Millisecond)
-	dm := db.NewDMap(name)
+	dm, err := db.NewDMap(name)
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	v, err := dm.Get(key)
 	if err != olric.ErrKeyNotFound {
 		t.Fatalf("Expected olric.ErrKeyNotFound. Got: %v", err)
@@ -252,7 +261,10 @@ func TestClient_LockWithTimeout(t *testing.T) {
 		t.Fatalf("Expected nil. Got: %v", err)
 	}
 
-	dm := db.NewDMap(name)
+	dm, err := db.NewDMap(name)
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	err = dm.Unlock(key)
 	if err != nil {
 		t.Fatalf("Expected nil. Got: %v", err)
diff --git a/dmap_atomic_test.go b/dmap_atomic_test.go
index 0b508548..1b78577b 100644
--- a/dmap_atomic_test.go
+++ b/dmap_atomic_test.go
@@ -48,7 +48,10 @@ func TestDMap_AtomicIncr(t *testing.T) {
 		}
 	}
 
-	dm := db.NewDMap("atomic_test")
+	dm, err := db.NewDMap("atomic_test")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	start = make(chan struct{})
 	for i := 0; i < 100; i++ {
 		wg.Add(1)
@@ -93,7 +96,10 @@ func TestDMap_AtomicDecr(t *testing.T) {
 		}
 	}
 
-	dm := db.NewDMap("atomic_test")
+	dm, err := db.NewDMap("atomic_test")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	start = make(chan struct{})
 	for i := 0; i < 100; i++ {
 		wg.Add(1)
@@ -142,7 +148,10 @@ func TestDMap_AtomicGetPut(t *testing.T) {
 		}
 	}
 
-	dm := db.NewDMap("atomic_test")
+	dm, err := db.NewDMap("atomic_test")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	start = make(chan struct{})
 	var final int64
 	for i := 0; i < 100; i++ {
diff --git a/dmap_backup_test.go b/dmap_backup_test.go
index e6a946c5..70148148 100644
--- a/dmap_backup_test.go
+++ b/dmap_backup_test.go
@@ -46,7 +46,10 @@ func TestDMap_PutBackup(t *testing.T) {
 	syncClusterMembers(db1, db2)
 
 	mname := "mymap"
-	dm := db1.NewDMap(mname)
+	dm, err := db1.NewDMap(mname)
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -56,10 +59,7 @@ func TestDMap_PutBackup(t *testing.T) {
 
 	for i := 0; i < 10; i++ {
 		key := bkey(i)
-		owner, hkey, err := dm.db.locateKey(mname, key)
-		if err != nil {
-			t.Fatalf("Expected nil. Got: %v", err)
-		}
+		owner, hkey := dm.db.locateKey(mname, key)
 		var backup = db1
 		if hostCmp(owner, db1.this) {
 			backup = db2
@@ -114,7 +114,10 @@ func TestDMap_DeleteBackup(t *testing.T) {
 	syncClusterMembers(db1, db2)
 
 	mname := "mymap"
-	dm := db1.NewDMap(mname)
+	dm, err := db1.NewDMap(mname)
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -131,10 +134,7 @@ func TestDMap_DeleteBackup(t *testing.T) {
 
 	for i := 0; i < 10; i++ {
 		key := bkey(i)
-		owner, hkey, err := dm.db.locateKey(mname, key)
-		if err != nil {
-			t.Fatalf("Expected nil. Got: %v", err)
-		}
+		owner, hkey := dm.db.locateKey(mname, key)
 		var backup = db1
 		if hostCmp(owner, db1.this) {
 			backup = db2
@@ -180,7 +180,10 @@ func TestDMap_GetBackup(t *testing.T) {
 	syncClusterMembers(db1, db2)
 
 	mname := "mymap"
-	dm := db1.NewDMap(mname)
+	dm, err := db1.NewDMap(mname)
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -190,10 +193,7 @@ func TestDMap_GetBackup(t *testing.T) {
 
 	for i := 0; i < 10; i++ {
 		key := bkey(i)
-		owner, hkey, err := dm.db.locateKey(mname, key)
-		if err != nil {
-			t.Fatalf("Expected nil. Got: %v", err)
-		}
+		owner, hkey := dm.db.locateKey(mname, key)
 		var kloc = db1
 		if !hostCmp(owner, db1.this) {
 			kloc = db2
diff --git a/dmap_delete.go b/dmap_delete.go
index 76c0952c..7787682b 100644
--- a/dmap_delete.go
+++ b/dmap_delete.go
@@ -110,10 +110,7 @@ func (db *Olric) delKeyVal(dm *dmap, hkey uint64, name, key string) error {
 }
 
 func (db *Olric) deleteKey(name, key string) error {
-	member, hkey, err := db.locateKey(name, key)
-	if err != nil {
-		return err
-	}
+	member, hkey := db.locateKey(name, key)
 	if !hostCmp(member, db.this) {
 		msg := &protocol.Message{
 			DMap: name,
diff --git a/dmap_delete_test.go b/dmap_delete_test.go
index fc290896..caaac7da 100644
--- a/dmap_delete_test.go
+++ b/dmap_delete_test.go
@@ -46,7 +46,10 @@ func TestDMap_Delete(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -91,7 +94,10 @@ func TestDMap_DeleteLookup(t *testing.T) {
 	}()
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -111,7 +117,10 @@ func TestDMap_DeleteLookup(t *testing.T) {
 	}()
 	syncClusterMembers(db1, db2, db3)
 
-	dm3 := db3.NewDMap("mymap")
+	dm3, err := db3.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		key := bkey(i)
 		err = dm3.Delete(key)
@@ -155,7 +164,10 @@ func TestDMap_DeleteStaleDMaps(t *testing.T) {
 	syncClusterMembers(db1, db2)
 
 	mname := "mymap"
-	dm := db1.NewDMap(mname)
+	dm, err := db1.NewDMap(mname)
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
diff --git a/dmap_destroy.go b/dmap_destroy.go
index 6d872fd7..88d2d696 100644
--- a/dmap_destroy.go
+++ b/dmap_destroy.go
@@ -20,10 +20,6 @@ import (
 )
 
 func (db *Olric) destroyDMap(name string) error {
-	if err := db.checkBootstrap(); err != nil {
-		return err
-	}
-
 	var g errgroup.Group
 	for _, item := range db.discovery.GetMembers() {
 		addr := item.String()
diff --git a/dmap_destroy_test.go b/dmap_destroy_test.go
index 94bf3101..c969901c 100644
--- a/dmap_destroy_test.go
+++ b/dmap_destroy_test.go
@@ -44,7 +44,10 @@ func TestDMap_Destroy(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
diff --git a/dmap_eviction_test.go b/dmap_eviction_test.go
index 3a076e11..ebcf31f4 100644
--- a/dmap_eviction_test.go
+++ b/dmap_eviction_test.go
@@ -48,7 +48,10 @@ func TestDMap_TTLEviction(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.PutEx(bkey(i), bval(i), time.Millisecond)
 		if err != nil {
@@ -93,7 +96,10 @@ func TestDMap_TTLDuration(t *testing.T) {
 	// This is not recommended but forgivable for testing.
 	db.config.Cache = &config.CacheConfig{TTLDuration: 10 * time.Millisecond}
 
-	dm := db.NewDMap("mymap")
+	dm, err := db.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -137,7 +143,10 @@ func TestDMap_TTLMaxIdleDuration(t *testing.T) {
 	// This is not recommended but forgivable for testing.
 	db.config.Cache = &config.CacheConfig{MaxIdleDuration: 10 * time.Millisecond}
 
-	dm := db.NewDMap("mymap")
+	dm, err := db.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -183,7 +192,10 @@ func TestDMap_EvictionPolicyLRU(t *testing.T) {
 	// We have 7 partitions in test setup. So MaxKeys is 10 for every partition.
 	db.config.Cache = &config.CacheConfig{MaxKeys: 70, EvictionPolicy: config.LRUEviction}
 
-	dm := db.NewDMap("mymap")
+	dm, err := db.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
diff --git a/dmap_get.go b/dmap_get.go
index f1a55411..b911b00d 100644
--- a/dmap_get.go
+++ b/dmap_get.go
@@ -255,10 +255,7 @@ func (db *Olric) callGetOnCluster(hkey uint64, name, key string) ([]byte, error)
 }
 
 func (db *Olric) get(name, key string) ([]byte, error) {
-	member, hkey, err := db.locateKey(name, key)
-	if err != nil {
-		return nil, err
-	}
+	member, hkey := db.locateKey(name, key)
 	// We are on the partition owner
 	if hostCmp(member, db.this) {
 		return db.callGetOnCluster(hkey, name, key)
diff --git a/dmap_get_test.go b/dmap_get_test.go
index f2b4414c..75987b06 100644
--- a/dmap_get_test.go
+++ b/dmap_get_test.go
@@ -49,7 +49,10 @@ func TestDMap_Get(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -94,7 +97,10 @@ func TestDMap_GetLookup(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -114,7 +120,10 @@ func TestDMap_GetLookup(t *testing.T) {
 	}()
 	syncClusterMembers(db1, db2, db3)
 
-	dm3 := db3.NewDMap("mymap")
+	dm3, err := db3.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		key := bkey(i)
 		value, err := dm3.Get(key)
@@ -141,7 +150,10 @@ func TestDMap_NilValue(t *testing.T) {
 
 	key := "mykey"
 	// Create a new DMap object and put a K/V pair.
-	dm := db.NewDMap("foobar")
+	dm, err := db.NewDMap("foobar")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	err = dm.Put(key, nil)
 	if err != nil {
 		t.Fatalf("Expected nil. Got: %v", err)
@@ -191,7 +203,10 @@ func TestDMap_NilValueWithTwoMembers(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), nil)
 		if err != nil {
@@ -199,7 +214,10 @@ func TestDMap_NilValueWithTwoMembers(t *testing.T) {
 		}
 	}
 
-	dm2 := db2.NewDMap("mymap")
+	dm2, err := db2.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		// Get the value and check it.
 		val, err := dm2.Get(bkey(i))
@@ -242,7 +260,10 @@ func TestDMap_GetReadQuorum(t *testing.T) {
 	}
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -272,10 +293,7 @@ func TestDMap_GetReadQuorum(t *testing.T) {
 	var hit bool
 	for i := 0; i < 10; i++ {
 		key := bkey(i)
-		host, _, err := db1.locateKey(dm.name, key)
-		if err != nil {
-			t.Fatalf("Expected nil. Got: %v", err)
-		}
+		host, _ := db1.locateKey(dm.name, key)
 		if hostCmp(db1.this, host) {
 			_, err = dm.Get(key)
 			if err != ErrReadQuorum {
@@ -320,7 +338,10 @@ func TestDMap_ReadRepair(t *testing.T) {
 	}
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
diff --git a/dmap_lock.go b/dmap_lock.go
index 44ea8660..f9954e57 100644
--- a/dmap_lock.go
+++ b/dmap_lock.go
@@ -117,17 +117,14 @@ func (db *Olric) lockKey(hkey uint64, name, key string, timeout time.Duration) e
 }
 
 func (db *Olric) lockWithTimeout(name, key string, timeout time.Duration) error {
-	member, hkey, err := db.locateKey(name, key)
-	if err != nil {
-		return err
-	}
+	member, hkey := db.locateKey(name, key)
 	if !hostCmp(member, db.this) {
 		req := &protocol.Message{
 			DMap:  name,
 			Key:   key,
 			Extra: protocol.LockWithTimeoutExtra{TTL: timeout.Nanoseconds()},
 		}
-		_, err = db.requestTo(member.String(), protocol.OpLockWithTimeout, req)
+		_, err := db.requestTo(member.String(), protocol.OpLockWithTimeout, req)
 		return err
 	}
 	return db.lockKey(hkey, name, key, timeout)
@@ -165,20 +162,13 @@ func (db *Olric) unlockKey(hkey uint64, name, key string) error {
 }
 
 func (db *Olric) unlock(name, key string) error {
-	if err := db.checkBootstrap(); err != nil {
-		return err
-	}
-
-	member, hkey, err := db.locateKey(name, key)
-	if err != nil {
-		return err
-	}
+	member, hkey := db.locateKey(name, key)
 	if !hostCmp(member, db.this) {
 		req := &protocol.Message{
 			DMap: name,
 			Key:  key,
 		}
-		_, err = db.requestTo(member.String(), protocol.OpUnlock, req)
+		_, err := db.requestTo(member.String(), protocol.OpUnlock, req)
 		return err
 	}
 	return db.unlockKey(hkey, name, key)
diff --git a/dmap_lock_test.go b/dmap_lock_test.go
index 2d78198f..0ff03818 100644
--- a/dmap_lock_test.go
+++ b/dmap_lock_test.go
@@ -35,7 +35,10 @@ func TestDMap_Locker_Standalone(t *testing.T) {
 	key := "mykey"
 	value := "myvalue"
 	// Create a new DMap object and put a K/V pair.
-	d := db.NewDMap("foobar")
+	d, err := db.NewDMap("foobar")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	err = d.Put(key, value)
 	if err != nil {
 		t.Fatalf("Expected nil. Got: %v", err)
@@ -75,7 +78,10 @@ func TestDMap_UnlockWithTwoHosts(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -87,7 +93,10 @@ func TestDMap_UnlockWithTwoHosts(t *testing.T) {
 		}
 	}
 
-	dm2 := db1.NewDMap("mymap")
+	dm2, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		key := bkey(i)
 		err := dm2.Unlock(key)
@@ -122,7 +131,10 @@ func TestDMap_LockWithTwoHosts(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -130,7 +142,10 @@ func TestDMap_LockWithTwoHosts(t *testing.T) {
 		}
 	}
 
-	dm2 := db2.NewDMap("mymap")
+	dm2, err := db2.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		key := bkey(i)
 		err = dm2.LockWithTimeout(key, time.Minute)
@@ -175,7 +190,10 @@ func TestDMap_Locker_LockWithTimeout(t *testing.T) {
 	key := "mykey"
 	value := "myvalue"
 	// Create a new DMap object and put a K/V pair.
-	dm := db.NewDMap("foobar")
+	dm, err := db.NewDMap("foobar")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	err = dm.Put(key, value)
 	if err != nil {
 		t.Fatalf("Expected nil. Got: %v", err)
@@ -227,7 +245,10 @@ func TestDMap_LockWithTimeoutOnNetwork(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -240,7 +261,10 @@ func TestDMap_LockWithTimeoutOnNetwork(t *testing.T) {
 	routingMtx.Lock()
 	defer routingMtx.Unlock()
 
-	dm2 := db2.NewDMap("mymap")
+	dm2, err := db2.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		key := bkey(i)
 		err = dm2.LockWithTimeout(key, 200*time.Millisecond)
@@ -284,7 +308,10 @@ func TestDMap_LockPrevious(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -292,7 +319,10 @@ func TestDMap_LockPrevious(t *testing.T) {
 		}
 	}
 
-	dm2 := db2.NewDMap("mymap")
+	dm2, err := db2.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		key := bkey(i)
 		err = dm2.LockWithTimeout(key, 200*time.Millisecond)
diff --git a/dmap_put.go b/dmap_put.go
index f8f7cc91..8d0f6456 100644
--- a/dmap_put.go
+++ b/dmap_put.go
@@ -189,17 +189,14 @@ func (db *Olric) callPutOnCluster(hkey uint64, w *writeop) error {
 // put controls every write operation in Olric. It redirects the requests to its owner,
 // if the key belongs to another host.
 func (db *Olric) put(opcode protocol.OpCode, w *writeop) error {
-	member, hkey, err := db.locateKey(w.dmap, w.key)
-	if err != nil {
-		return err
-	}
+	member, hkey := db.locateKey(w.dmap, w.key)
 	if hostCmp(member, db.this) {
 		// We are on the partition owner.
 		return db.callPutOnCluster(hkey, w)
 	}
 	// Redirect to the partition owner.
 	req := w.toReq(opcode)
-	_, err = db.requestTo(member.String(), opcode, req)
+	_, err := db.requestTo(member.String(), opcode, req)
 	return err
 }
 
diff --git a/dmap_put_test.go b/dmap_put_test.go
index 6b629a52..f0c353bf 100644
--- a/dmap_put_test.go
+++ b/dmap_put_test.go
@@ -50,14 +50,20 @@ func TestDMap_Put(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
 			t.Fatalf("Expected nil. Got: %v", err)
 		}
 	}
-	dm2 := db2.NewDMap("mymap")
+	dm2, err := db2.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		val, err := dm2.Get(bkey(i))
 		if err != nil {
@@ -93,7 +99,10 @@ func TestDMap_PutEx(t *testing.T) {
 	}()
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		err = dm.PutEx(bkey(i), bval(i), time.Millisecond)
 		if err != nil {
@@ -166,13 +175,13 @@ func TestDMap_PutWriteQuorum(t *testing.T) {
 	syncClusterMembers(db1)
 
 	var hit bool
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 10; i++ {
 		key := bkey(i)
-		host, _, err := db1.locateKey(dm.name, key)
-		if err != nil {
-			t.Fatalf("Expected nil. Got: %v", err)
-		}
+		host, _ := db1.locateKey(dm.name, key)
 		if hostCmp(db1.this, host) {
 			err = dm.Put(key, bval(i))
 			if err != ErrWriteQuorum {
diff --git a/dmap_test.go b/dmap_test.go
index 8dce5722..026a4b1d 100644
--- a/dmap_test.go
+++ b/dmap_test.go
@@ -143,7 +143,10 @@ func TestDMap_Standalone(t *testing.T) {
 	key := "mykey"
 	value := "myvalue"
 	// Create a new DMap object and put a K/V pair.
-	d := db.NewDMap("foobar")
+	d, err := db.NewDMap("foobar")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	err = d.Put(key, value)
 	if err != nil {
 		t.Fatalf("Expected nil. Got: %v", err)
@@ -192,7 +195,10 @@ func TestDMap_PruneHosts(t *testing.T) {
 	}()
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -284,7 +290,10 @@ func TestDMap_CrashServer(t *testing.T) {
 	}
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -316,7 +325,10 @@ func TestDMap_CrashServer(t *testing.T) {
 		}
 	}
 
-	dm2 := db2.NewDMap("mymap")
+	dm2, err := db2.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		_, err = dm2.Get(bkey(i))
 		if err != nil {
diff --git a/olric.go b/olric.go
index b94876d8..904891c0 100644
--- a/olric.go
+++ b/olric.go
@@ -134,11 +134,14 @@ type DMap struct {
 }
 
 // NewDMap creates an returns a new DMap object.
-func (db *Olric) NewDMap(name string) *DMap {
+func (db *Olric) NewDMap(name string) (*DMap, error) {
+	if err := db.checkBootstrap(); err != nil {
+		return nil, err
+	}
 	return &DMap{
 		name: name,
 		db:   db,
-	}
+	}, nil
 }
 
 // New creates a new Olric object, otherwise returns an error.
@@ -422,20 +425,9 @@ func (db *Olric) getHKey(name, key string) uint64 {
 	return db.hasher.Sum64(*(*[]byte)(unsafe.Pointer(&tmp)))
 }
 
-func (db *Olric) locateHKey(hkey uint64) (discovery.Host, error) {
-	if err := db.checkBootstrap(); err != nil {
-		return discovery.Host{}, err
-	}
-	return db.getPartition(hkey).owner(), nil
-}
-
-func (db *Olric) locateKey(name, key string) (discovery.Host, uint64, error) {
+func (db *Olric) locateKey(name, key string) (discovery.Host, uint64) {
 	hkey := db.getHKey(name, key)
-	member, err := db.locateHKey(hkey)
-	if err != nil {
-		return discovery.Host{}, 0, err
-	}
-	return member, hkey, nil
+	return db.getPartition(hkey).owner(), hkey
 }
 
 func (db *Olric) setCacheConfiguration(dm *dmap, name string) {
diff --git a/pipeline_test.go b/pipeline_test.go
index 06f19919..3f3287a0 100644
--- a/pipeline_test.go
+++ b/pipeline_test.go
@@ -71,7 +71,10 @@ func TestPipeline(t *testing.T) {
 		t.Fatalf("Expected status: %v. Got: %v", protocol.StatusOK, resp.Status)
 	}
 
-	dm := db.NewDMap(dmap)
+	dm, err := db.NewDMap(dmap)
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	val, err := dm.Get(key)
 	if err != nil {
 		t.Fatalf("Expected nil. Got: %v", err)
diff --git a/rebalancer_test.go b/rebalancer_test.go
index 22f88c44..b4d3a42b 100644
--- a/rebalancer_test.go
+++ b/rebalancer_test.go
@@ -46,7 +46,10 @@ func TestRebalance_Merge(t *testing.T) {
 	}()
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -94,7 +97,10 @@ func TestRebalance_MergeWithNewValues(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -102,7 +108,10 @@ func TestRebalance_MergeWithNewValues(t *testing.T) {
 		}
 	}
 
-	dm2 := db2.NewDMap("mymap")
+	dm2, err := db2.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 101; i++ {
 		if i == 3 {
 			continue
@@ -155,7 +164,10 @@ func TestRebalance_MergeWithLock(t *testing.T) {
 
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -167,7 +179,10 @@ func TestRebalance_MergeWithLock(t *testing.T) {
 		}
 	}
 
-	dm2 := db2.NewDMap("mymap")
+	dm2, err := db2.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm2.Unlock(bkey(i))
 		if err != nil {
diff --git a/stats_test.go b/stats_test.go
index bb4246a2..4dd66640 100644
--- a/stats_test.go
+++ b/stats_test.go
@@ -31,7 +31,10 @@ func TestStatsStandalone(t *testing.T) {
 		}
 	}()
 
-	dm := db.NewDMap("mymap")
+	dm, err := db.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {
@@ -89,7 +92,10 @@ func TestStatsCluster(t *testing.T) {
 	}()
 	syncClusterMembers(db1, db2)
 
-	dm := db1.NewDMap("mymap")
+	dm, err := db1.NewDMap("mymap")
+	if err != nil {
+		t.Fatalf("Expected nil. Got: %v", err)
+	}
 	for i := 0; i < 100; i++ {
 		err = dm.Put(bkey(i), bval(i))
 		if err != nil {