diff --git a/.idea/codeStyleSettings.xml b/.idea/codeStyleSettings.xml
index 13da8a541b7..139e2ef95f0 100644
--- a/.idea/codeStyleSettings.xml
+++ b/.idea/codeStyleSettings.xml
@@ -11,8 +11,10 @@
           <option name="XML_LEGACY_SETTINGS_IMPORTED" value="true" />
         </XML>
         <codeStyleSettings language="JAVA">
+          <option name="KEEP_BLANK_LINES_IN_DECLARATIONS" value="1" />
+          <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
+          <option name="KEEP_BLANK_LINES_BEFORE_RBRACE" value="1" />
           <option name="ALIGN_MULTILINE_CHAINED_METHODS" value="true" />
-          <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
           <option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
           <option name="ALIGN_MULTILINE_TERNARY_OPERATION" value="true" />
           <option name="ALIGN_MULTILINE_EXTENDS_LIST" value="true" />
diff --git a/.travis.yml b/.travis.yml
index c1fbb632799..5d97f7740a3 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,3 +6,5 @@ before_install:
 after_success:
   # See: https://github.com/codecov/example-java/blob/master/.travis.yml
   - bash <(curl -s https://codecov.io/bash)
+
+script: ./gradlew check --stacktrace
diff --git a/build.gradle b/build.gradle
index a75eb0c2973..1059b75f4fa 100644
--- a/build.gradle
+++ b/build.gradle
@@ -54,7 +54,7 @@ allprojects {
     apply plugin: 'idea'
 
     group = 'org.spine3'
-    version = '0.5.19-SNAPSHOT'
+    version = '0.6.0-SNAPSHOT'
 }
 
 ext {
diff --git a/client/src/main/java/org/spine3/base/Commands.java b/client/src/main/java/org/spine3/base/Commands.java
index 0af4c384d34..d29c1cfc3e0 100644
--- a/client/src/main/java/org/spine3/base/Commands.java
+++ b/client/src/main/java/org/spine3/base/Commands.java
@@ -47,7 +47,7 @@
 import static org.spine3.base.CommandContext.newBuilder;
 import static org.spine3.base.Identifiers.idToString;
 import static org.spine3.protobuf.Timestamps.getCurrentTime;
-import static org.spine3.validate.Validate.checkIsPositive;
+import static org.spine3.validate.Validate.checkPositive;
 import static org.spine3.validate.Validate.checkNotEmptyOrBlank;
 import static org.spine3.validate.Validate.isNotDefault;
 
@@ -287,7 +287,7 @@ public static Command setSchedulingTime(Command command, Timestamp schedulingTim
      */
     @Internal
     public static Command setSchedule(Command command, Duration delay, Timestamp schedulingTime) {
-        checkIsPositive(schedulingTime, "command scheduling time");
+        checkPositive(schedulingTime, "command scheduling time");
         final CommandContext context = command.getContext();
         final CommandContext.Schedule scheduleUpdated = context.getSchedule()
                                                                .toBuilder()
diff --git a/client/src/main/java/org/spine3/base/Queries.java b/client/src/main/java/org/spine3/base/Queries.java
new file mode 100644
index 00000000000..14cf708d807
--- /dev/null
+++ b/client/src/main/java/org/spine3/base/Queries.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.base;
+
+import com.google.protobuf.Any;
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.Message;
+import org.spine3.client.EntityFilters;
+import org.spine3.client.EntityId;
+import org.spine3.client.EntityIdFilter;
+import org.spine3.client.Query;
+import org.spine3.client.Target;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.KnownTypes;
+import org.spine3.protobuf.TypeUrl;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.Set;
+
+import static org.spine3.base.Queries.Targets.allOf;
+import static org.spine3.base.Queries.Targets.someOf;
+
+/**
+ * Client-side utilities for working with queries.
+ *
+ * @author Alex Tymchenko
+ * @author Dmytro Dashenkov
+ */
+public class Queries {
+
+    private Queries() {
+    }
+
+    /**
+     * Create a {@link Query} to read certain entity states by IDs with the {@link FieldMask}
+     * applied to each of the results.
+     *
+     * <p>Allows to specify a set of identifiers to be used during the {@code Query} processing. The processing
+     * results will contain only the entities, which IDs are present among the {@code ids}.
+     *
+     * <p>Allows to set property paths for a {@link FieldMask}, applied to each of the query results.
+     * This processing is performed according to the
+     * <a href="https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.FieldMask>FieldMask specs</a>.
+     *
+     * <p>In case the {@code paths} array contains entries inapplicable to the resulting entity
+     * (e.g. a {@code path} references a missing field), such invalid paths are silently ignored.
+     *
+     * @param entityClass the class of a target entity
+     * @param ids         the entity IDs of interest
+     * @param paths       the property paths for the {@code FieldMask} applied to each of results
+     * @return an instance of {@code Query} formed according to the passed parameters
+     */
+    public static Query readByIds(Class<? extends Message> entityClass, Set<? extends Message> ids, String... paths) {
+        final FieldMask fieldMask = FieldMask.newBuilder()
+                                             .addAllPaths(Arrays.asList(paths))
+                                             .build();
+        final Query result = composeQuery(entityClass, ids, fieldMask);
+        return result;
+    }
+
+    /**
+     * Create a {@link Query} to read all entity states with the {@link FieldMask}
+     * applied to each of the results.
+     *
+     * <p>Allows to set property paths for a {@link FieldMask}, applied to each of the query results.
+     * This processing is performed according to the
+     * <a href="https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.FieldMask>FieldMask specs</a>.
+     *
+     * <p>In case the {@code paths} array contains entries inapplicable to the resulting entity
+     * (e.g. a {@code path} references a missing field), such invalid paths are silently ignored.
+     *
+     * @param entityClass the class of a target entity
+     * @param paths       the property paths for the {@code FieldMask} applied to each of results
+     * @return an instance of {@code Query} formed according to the passed parameters
+     */
+    public static Query readAll(Class<? extends Message> entityClass, String... paths) {
+        final FieldMask fieldMask = FieldMask.newBuilder()
+                                             .addAllPaths(Arrays.asList(paths))
+                                             .build();
+        final Query result = composeQuery(entityClass, null, fieldMask);
+        return result;
+    }
+
+    /**
+     * Create a {@link Query} to read certain entity states by IDs.
+     *
+     * <p>Allows to specify a set of identifiers to be used during the {@code Query} processing. The processing
+     * results will contain only the entities, which IDs are present among the {@code ids}.
+     *
+     * <p>Unlike {@link Queries#readByIds(Class, Set, String...)}, the {@code Query} processing will not change
+     * the resulting entities.
+     *
+     * @param entityClass the class of a target entity
+     * @param ids         the entity IDs of interest
+     * @return an instance of {@code Query} formed according to the passed parameters
+     */
+    public static Query readByIds(Class<? extends Message> entityClass, Set<? extends Message> ids) {
+        return composeQuery(entityClass, ids, null);
+    }
+
+    /**
+     * Create a {@link Query} to read all states of a certain entity.
+     *
+     * <p>Unlike {@link Queries#readAll(Class, String...)}, the {@code Query} processing will not change
+     * the resulting entities.
+     *
+     * @param entityClass the class of a target entity
+     * @return an instance of {@code Query} formed according to the passed parameters
+     */
+    public static Query readAll(Class<? extends Message> entityClass) {
+        return composeQuery(entityClass, null, null);
+    }
+
+    private static Query composeQuery(Class<? extends Message> entityClass, @Nullable Set<? extends Message> ids, @Nullable FieldMask fieldMask) {
+        final Target target = ids == null ? allOf(entityClass) : someOf(entityClass, ids);
+        final Query.Builder queryBuilder = Query.newBuilder()
+                                                .setTarget(target);
+        if (fieldMask != null) {
+            queryBuilder.setFieldMask(fieldMask);
+        }
+        final Query result = queryBuilder
+                .build();
+        return result;
+    }
+
+    /**
+     * Extract the type of {@link Target} for the given {@link Query}.
+     *
+     * <p>Returns null if the {@code Target} type is unknown to the application.
+     *
+     * @param query the query of interest.
+     * @return the type of the {@code Query#getTarget()} or null, if the type is unknown.
+     */
+    @Nullable
+    public static TypeUrl typeOf(Query query) {
+        final Target target = query.getTarget();
+        final String typeAsString = target.getType();
+        final TypeUrl type = KnownTypes.getTypeUrl(typeAsString);
+        return type;
+    }
+
+    /**
+     * Client-side utilities for working with {@link Query} and {@link org.spine3.client.Subscription} targets.
+     *
+     * @author Alex Tymchenko
+     * @author Dmytro Dashenkov
+     */
+    public static class Targets {
+
+        private Targets() {
+        }
+
+        /**
+         * Create a {@link Target} for a subset of the entity states by specifying their IDs.
+         *
+         * @param entityClass the class of a target entity
+         * @param ids         the IDs of interest
+         * @return the instance of {@code Target} assembled according to the parameters.
+         */
+        public static Target someOf(Class<? extends Message> entityClass, Set<? extends Message> ids) {
+            final Target result = composeTarget(entityClass, ids);
+            return result;
+        }
+
+        /**
+         * Create a {@link Target} for all of the specified entity states.
+         *
+         * @param entityClass the class of a target entity
+         * @return the instance of {@code Target} assembled according to the parameters.
+         */
+        public static Target allOf(Class<? extends Message> entityClass) {
+            final Target result = composeTarget(entityClass, null);
+            return result;
+        }
+
+        /* package */
+        static Target composeTarget(Class<? extends Message> entityClass, @Nullable Set<? extends Message> ids) {
+            final TypeUrl type = TypeUrl.of(entityClass);
+
+            final boolean includeAll = ids == null;
+
+            final EntityIdFilter.Builder idFilterBuilder = EntityIdFilter.newBuilder();
+
+            if (!includeAll) {
+                for (Message rawId : ids) {
+                    final Any packedId = AnyPacker.pack(rawId);
+                    final EntityId entityId = EntityId.newBuilder()
+                                                      .setId(packedId)
+                                                      .build();
+                    idFilterBuilder.addIds(entityId);
+                }
+            }
+            final EntityIdFilter idFilter = idFilterBuilder.build();
+            final EntityFilters filters = EntityFilters.newBuilder()
+                                                       .setIdFilter(idFilter)
+                                                       .build();
+            final Target.Builder builder = Target.newBuilder()
+                                                 .setType(type.getTypeName());
+            if (includeAll) {
+                builder.setIncludeAll(true);
+            } else {
+                builder.setFilters(filters);
+            }
+
+            return builder.build();
+        }
+    }
+}
diff --git a/client/src/main/java/org/spine3/protobuf/KnownTypes.java b/client/src/main/java/org/spine3/protobuf/KnownTypes.java
index d4755da2bfe..e5e70721e7e 100644
--- a/client/src/main/java/org/spine3/protobuf/KnownTypes.java
+++ b/client/src/main/java/org/spine3/protobuf/KnownTypes.java
@@ -63,6 +63,7 @@
 import org.spine3.protobuf.error.UnknownTypeException;
 import org.spine3.type.ClassName;
 
+import javax.annotation.Nullable;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
@@ -105,8 +106,8 @@ public class KnownTypes {
      */
     private static final ImmutableMap<String, TypeUrl> typeNameToUrlMap = buildTypeToUrlMap(knownTypes);
 
-
-    private KnownTypes() {}
+    private KnownTypes() {
+    }
 
     /** Retrieves Protobuf type URLs known to the application. */
     public static ImmutableSet<TypeUrl> getTypeUrls() {
@@ -145,7 +146,8 @@ public static ClassName getClassName(TypeUrl typeUrl) throws UnknownTypeExceptio
      * @throws IllegalStateException if there is no Protobuf type for the specified class
      */
     public static TypeUrl getTypeUrl(ClassName className) {
-        final TypeUrl result = knownTypes.inverse().get(className);
+        final TypeUrl result = knownTypes.inverse()
+                                         .get(className);
         if (result == null) {
             throw new IllegalStateException("No Protobuf type URL found for the Java class " + className);
         }
@@ -153,6 +155,7 @@ public static TypeUrl getTypeUrl(ClassName className) {
     }
 
     /** Returns a Protobuf type URL by Protobuf type name. */
+    @Nullable
     public static TypeUrl getTypeUrl(String typeName) {
         final TypeUrl typeUrl = typeNameToUrlMap.get(typeName);
         return typeUrl;
@@ -203,7 +206,8 @@ private void putProperties(Properties properties) {
          * <p>This method needs to be updated with introduction of new Google Protobuf types
          * after they are used in the framework.
          */
-        @SuppressWarnings("OverlyLongMethod") // OK as there are many types in Protobuf and we want to keep this code in one place.
+        @SuppressWarnings("OverlyLongMethod")
+        // OK as there are many types in Protobuf and we want to keep this code in one place.
         private Builder addStandardProtobufTypes() {
             // Types from `any.proto`.
             put(Any.class);
@@ -217,14 +221,14 @@ private Builder addStandardProtobufTypes() {
             put(DescriptorProtos.FileDescriptorSet.class);
             put(DescriptorProtos.FileDescriptorProto.class);
             put(DescriptorProtos.DescriptorProto.class);
-                // Inner types of `DescriptorProto`
-                put(DescriptorProtos.DescriptorProto.ExtensionRange.class);
-                put(DescriptorProtos.DescriptorProto.ReservedRange.class);
+            // Inner types of `DescriptorProto`
+            put(DescriptorProtos.DescriptorProto.ExtensionRange.class);
+            put(DescriptorProtos.DescriptorProto.ReservedRange.class);
 
             put(DescriptorProtos.FieldDescriptorProto.class);
-                putEnum(DescriptorProtos.FieldDescriptorProto.Type.getDescriptor(),
-                        DescriptorProtos.FieldDescriptorProto.Type.class);
-                putEnum(DescriptorProtos.FieldDescriptorProto.Label.getDescriptor(),
+            putEnum(DescriptorProtos.FieldDescriptorProto.Type.getDescriptor(),
+                    DescriptorProtos.FieldDescriptorProto.Type.class);
+            putEnum(DescriptorProtos.FieldDescriptorProto.Label.getDescriptor(),
                     DescriptorProtos.FieldDescriptorProto.Label.class);
 
             put(DescriptorProtos.OneofDescriptorProto.class);
@@ -237,21 +241,21 @@ private Builder addStandardProtobufTypes() {
                     DescriptorProtos.FileOptions.OptimizeMode.class);
             put(DescriptorProtos.MessageOptions.class);
             put(DescriptorProtos.FieldOptions.class);
-                putEnum(DescriptorProtos.FieldOptions.CType.getDescriptor(),
-                        DescriptorProtos.FieldOptions.CType.class);
-                putEnum(DescriptorProtos.FieldOptions.JSType.getDescriptor(),
-                        DescriptorProtos.FieldOptions.JSType.class);
+            putEnum(DescriptorProtos.FieldOptions.CType.getDescriptor(),
+                    DescriptorProtos.FieldOptions.CType.class);
+            putEnum(DescriptorProtos.FieldOptions.JSType.getDescriptor(),
+                    DescriptorProtos.FieldOptions.JSType.class);
             put(DescriptorProtos.EnumOptions.class);
             put(DescriptorProtos.EnumValueOptions.class);
             put(DescriptorProtos.ServiceOptions.class);
             put(DescriptorProtos.MethodOptions.class);
             put(DescriptorProtos.UninterpretedOption.class);
             put(DescriptorProtos.SourceCodeInfo.class);
-                // Inner types of `SourceCodeInfo`.
-                put(DescriptorProtos.SourceCodeInfo.Location.class);
+            // Inner types of `SourceCodeInfo`.
+            put(DescriptorProtos.SourceCodeInfo.Location.class);
             put(DescriptorProtos.GeneratedCodeInfo.class);
-                // Inner types of `GeneratedCodeInfo`.
-                put(DescriptorProtos.GeneratedCodeInfo.Annotation.class);
+            // Inner types of `GeneratedCodeInfo`.
+            put(DescriptorProtos.GeneratedCodeInfo.Annotation.class);
 
             // Types from `duration.proto`.
             put(Duration.class);
@@ -277,8 +281,8 @@ private Builder addStandardProtobufTypes() {
             // Types from `type.proto`.
             put(Type.class);
             put(Field.class);
-                putEnum(Field.Kind.getDescriptor(), Field.Kind.class);
-                putEnum(Field.Cardinality.getDescriptor(), Field.Cardinality.class);
+            putEnum(Field.Kind.getDescriptor(), Field.Kind.class);
+            putEnum(Field.Cardinality.getDescriptor(), Field.Cardinality.class);
             put(com.google.protobuf.Enum.class);
             put(EnumValue.class);
             put(Option.class);
@@ -313,8 +317,8 @@ private void putEnum(EnumDescriptor desc, Class<? extends EnumLite> enumClass) {
         private void put(TypeUrl typeUrl, ClassName className) {
             if (resultMap.containsKey(typeUrl)) {
                 log().warn("Duplicate key in the {} map: {}. " +
-                "It may be caused by the `task.descriptorSetOptions.includeImports` option " +
-                "set to `true` in the `build.gradle`.", KnownTypes.class.getName(), typeUrl);
+                                   "It may be caused by the `task.descriptorSetOptions.includeImports` option " +
+                                   "set to `true` in the `build.gradle`.", KnownTypes.class.getName(), typeUrl);
                 return;
             }
             resultMap.put(typeUrl, className);
diff --git a/client/src/main/java/org/spine3/protobuf/Timestamps.java b/client/src/main/java/org/spine3/protobuf/Timestamps.java
index bef01a178d8..e66d9c30840 100644
--- a/client/src/main/java/org/spine3/protobuf/Timestamps.java
+++ b/client/src/main/java/org/spine3/protobuf/Timestamps.java
@@ -203,9 +203,9 @@ public static int compare(@Nullable Timestamp t1, @Nullable Timestamp t2) {
             return 1;
         }
         int result = Long.compare(t1.getSeconds(), t2.getSeconds());
-        result = (result == 0) ?
-                 Integer.compare(t1.getNanos(), t2.getNanos()) :
-                 result;
+        result = (result == 0)
+                 ? Integer.compare(t1.getNanos(), t2.getNanos())
+                 : result;
         return result;
     }
 
diff --git a/client/src/main/java/org/spine3/protobuf/TypeUrl.java b/client/src/main/java/org/spine3/protobuf/TypeUrl.java
index 75bb0abbd25..f8eae45933e 100644
--- a/client/src/main/java/org/spine3/protobuf/TypeUrl.java
+++ b/client/src/main/java/org/spine3/protobuf/TypeUrl.java
@@ -122,9 +122,9 @@ public static TypeUrl of(EnumDescriptor descriptor) {
     @Internal
     public static TypeUrl of(String typeUrlOrName) {
         checkNotEmptyOrBlank(typeUrlOrName, "type URL or name");
-        final TypeUrl typeUrl = isTypeUrl(typeUrlOrName) ?
-                                ofTypeUrl(typeUrlOrName) :
-                                ofTypeName(typeUrlOrName);
+        final TypeUrl typeUrl = isTypeUrl(typeUrlOrName)
+                                ? ofTypeUrl(typeUrlOrName)
+                                : ofTypeName(typeUrlOrName);
         return typeUrl;
     }
 
diff --git a/client/src/main/java/org/spine3/validate/Validate.java b/client/src/main/java/org/spine3/validate/Validate.java
index f5a2a66e487..325edb680f0 100644
--- a/client/src/main/java/org/spine3/validate/Validate.java
+++ b/client/src/main/java/org/spine3/validate/Validate.java
@@ -187,7 +187,7 @@ public static String checkNotEmptyOrBlank(String stringToCheck, String fieldName
      * @return the passed timestamp
      * @throws IllegalArgumentException if any of the requirements are not met
      */
-    public static Timestamp checkIsPositive(Timestamp timestamp, String nameToLog) {
+    public static Timestamp checkPositive(Timestamp timestamp, String nameToLog) {
         checkNotNull(timestamp, nameToLog + " is null.");
         checkArgument(timestamp.getSeconds() > 0, nameToLog + " must have a positive number of seconds.");
         checkArgument(timestamp.getNanos() >= 0, nameToLog + " must not have a negative number of nanoseconds.");
diff --git a/client/src/main/proto/spine/client/command_service.proto b/client/src/main/proto/spine/client/command_service.proto
new file mode 100644
index 00000000000..c8e1b2a3ea3
--- /dev/null
+++ b/client/src/main/proto/spine/client/command_service.proto
@@ -0,0 +1,42 @@
+//
+// Copyright 2016, TeamDev Ltd. All rights reserved.
+//
+// Redistribution and use in source and/or binary forms, with or without
+// modification, must retain the above copyright notice and the following
+// disclaimer.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+syntax = "proto3";
+
+package spine.client;
+
+// We put gRPC-based classes into `grpc` sub-package, which is annotated as `@Internal`
+// to hide implementation details from the public API of the framework.
+option (type_url_prefix) = "type.spine3.org";
+option java_package = "org.spine3.client.grpc";
+option java_multiple_files = true;
+option java_outer_classname = "CommandServiceProto";
+option java_generate_equals_and_hash = true;
+
+import "spine/annotations.proto";
+import "spine/base/command.proto";
+import "spine/base/response.proto";
+
+
+// A service for sending commands from clients.
+service CommandService {
+
+    // Request to handle a command.
+    rpc Post(base.Command) returns (base.Response);
+}
diff --git a/client/src/main/proto/spine/client/entities.proto b/client/src/main/proto/spine/client/entities.proto
new file mode 100644
index 00000000000..ab9d3596f09
--- /dev/null
+++ b/client/src/main/proto/spine/client/entities.proto
@@ -0,0 +1,85 @@
+//
+// Copyright 2016, TeamDev Ltd. All rights reserved.
+//
+// Redistribution and use in source and/or binary forms, with or without
+// modification, must retain the above copyright notice and the following
+// disclaimer.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+syntax = "proto3";
+
+package spine.client;
+
+option (type_url_prefix) = "type.spine3.org";
+option java_generate_equals_and_hash = true;
+option java_multiple_files = true;
+option java_outer_classname = "EntitiesProto";
+option java_package = "org.spine3.client";
+
+import "google/protobuf/any.proto";
+
+import "spine/annotations.proto";
+
+// Represents an ID of an entity.
+//
+// Acts as an read-side API identifier for Projection state, Aggregate state and other entities.
+message EntityId {
+
+    // An ID of an entity.
+    google.protobuf.Any id = 1;
+}
+
+// Defines the entity type and filters.
+//
+// Use Target to specify and narrow down the source for Topic and Query by an entity type and various criteria.
+message Target {
+
+    // Represents TypeUrl for the entity of interest.
+    string type = 1;
+
+    // Modifies the entity collection of a specified type.
+    // Allows either to narrow it down by filtering out the entity objects or include all entity instances
+    // into the target.
+    oneof criterion {
+
+        // The instruction to include all objects of a given type.
+        bool include_all = 2;
+
+        // Filter the objects of a given type by certain criteria.
+        EntityFilters filters = 3;
+    }
+}
+
+// Set of filters used to modify the entity collection.
+//
+// To be used in scope of read-side API for specifying the target of query and subscription operations.
+message EntityFilters {
+
+    // Match entities by IDs.
+    EntityIdFilter id_filter = 1;
+
+    // Reserved for more filter types
+    reserved 2 to 40;
+}
+
+// Allows to add an ID filter for the read operations.
+//
+// Used to modify the collection of interest by filtering out the objects with identifiers not included into the filter.
+// SQL equivalent is "... where entity.id IN (...)".
+message EntityIdFilter {
+
+    // The collection of entity IDs.
+    repeated EntityId ids = 1;
+}
+
diff --git a/client/src/main/proto/spine/client/query.proto b/client/src/main/proto/spine/client/query.proto
index 0280acc61d9..3b8cb2c0a0c 100644
--- a/client/src/main/proto/spine/client/query.proto
+++ b/client/src/main/proto/spine/client/query.proto
@@ -27,11 +27,50 @@ option java_multiple_files = true;
 option java_outer_classname = "QueryProto";
 option java_package = "org.spine3.client";
 
+
+import "google/protobuf/any.proto";
+import "google/protobuf/field_mask.proto";
+
 import "spine/annotations.proto";
 import "spine/ui/language.proto";
+import "spine/base/response.proto";
+import "spine/client/entities.proto";
+
 
 message QueryContext {
 
     ui.Language language = 1;
     //TODO:2015-12-16:alexander.yevsyukov: Finish
-}
\ No newline at end of file
+}
+
+// The main abstraction over the read-side API.
+//
+// Allows clients to form the requests to the read-side through the `QueryService`.
+// `Query` execution typically results in a QueryResponse object.
+message Query {
+
+    // Defines the entity of interest, e.g. entity type URL and a set of fetch criteria.
+    Target target = 1;
+
+    // Field mask to be applied to the items of the query result.
+    google.protobuf.FieldMask field_mask = 2;
+
+    // Reserved for utility fields like query creation date, required response timeframe etc.
+    reserved 3 to 6;
+}
+
+// The result of `Query` processing.
+//
+// Contains the actual processing results and other response attributes.
+// Used as a result of {@code QueryService#Read(Query)} gRPC method call.
+message QueryResponse {
+
+    // Represents the base part of the response. I.e. whether the `Query` has been acked or not.
+    base.Response response = 1;
+
+    // Reserved for more query response attributes, e.g. to describe paginated response etc.
+    reserved 2 to 4;
+
+    // Entity states (each packed as `Any`) returned to the API user as a result of Query execution.
+    repeated google.protobuf.Any messages = 5;
+}
diff --git a/client/src/main/proto/spine/client/query_service.proto b/client/src/main/proto/spine/client/query_service.proto
new file mode 100644
index 00000000000..36e7afec695
--- /dev/null
+++ b/client/src/main/proto/spine/client/query_service.proto
@@ -0,0 +1,39 @@
+//
+// Copyright 2016, TeamDev Ltd. All rights reserved.
+//
+// Redistribution and use in source and/or binary forms, with or without
+// modification, must retain the above copyright notice and the following
+// disclaimer.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+syntax = "proto3";
+
+package spine.client;
+
+option (type_url_prefix) = "type.spine3.org";
+option java_package = "org.spine3.client.grpc";
+option java_multiple_files = true;
+option java_outer_classname = "QueryServiceProto";
+option java_generate_equals_and_hash = true;
+
+
+import "spine/annotations.proto";
+import "spine/client/query.proto";
+
+// A service for querying the read-side from clients.
+service QueryService {
+
+    // Reads a certain data from the read-side by setting the criteria via Query.
+    rpc Read (Query) returns (QueryResponse);
+}
diff --git a/client/src/main/proto/spine/client/subscription.proto b/client/src/main/proto/spine/client/subscription.proto
new file mode 100644
index 00000000000..14e221a2546
--- /dev/null
+++ b/client/src/main/proto/spine/client/subscription.proto
@@ -0,0 +1,91 @@
+//
+// Copyright 2016, TeamDev Ltd. All rights reserved.
+//
+// Redistribution and use in source and/or binary forms, with or without
+// modification, must retain the above copyright notice and the following
+// disclaimer.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+syntax = "proto3";
+
+package spine.client;
+
+option (type_url_prefix) = "type.spine3.org";
+option java_generate_equals_and_hash = true;
+option java_multiple_files = true;
+option java_outer_classname = "SubscriptionProto";
+option java_package = "org.spine3.client";
+
+
+import "google/protobuf/any.proto";
+import "google/protobuf/field_mask.proto";
+
+import "spine/annotations.proto";
+import "spine/base/response.proto";
+import "spine/client/entities.proto";
+
+// An object defining a unit of subscription.
+//
+// Defines the target (entities and criteria) of subscription.
+message Topic {
+
+    // Defines the entity of interest, e.g. entity type URL and a set of subscription criteria.
+    Target target = 1;
+
+    // Field mask to be applied to the entity updates applicable to this topic.
+    //
+    // Applied to each of the entity state messages before returning in scope of SubscriptionUpdate.
+    google.protobuf.FieldMask field_mask = 2;
+
+    // Reserved for utility fields.
+    reserved 3 to 6;
+}
+
+// Wrapped collection of read-side entity updates on a topic with the specific subscription ID.
+message SubscriptionUpdate {
+
+    // The subscription in which scope this update is propagated.
+    Subscription subscription = 1;
+
+    // Represents the base part of the response. I.e. whether the Topic subscription requires has been acked or not.
+    base.Response response = 2;
+
+    // Reserved for more subscription update attributes.
+    reserved 3 to 9;
+
+    // Entity updates packed as Any.
+    //
+    // Each of the update messages is affected by the field mask set for the current subscription.
+    repeated google.protobuf.Any updates = 10;
+}
+
+// The subscription object.
+//
+// Created when the client subscribes to a topic inside the read-side implementation.
+// Generally should not be created in the client code.
+// See SubscriptionService#Subscribe(Topic).
+message Subscription {
+
+    // Unique identifier of the subscription.
+    //
+    // Typically built using Java's UUID.toString() functionality.
+    // Must be unique in scope of a bounded context.
+    string id = 1;
+
+    // Represents TypeUrl of the target entity for this subscription.
+    string type = 2;
+
+    // Reserved for subscription attributes.
+    reserved 3 to 10;
+}
diff --git a/client/src/main/proto/spine/client/client_service.proto b/client/src/main/proto/spine/client/subscription_service.proto
similarity index 53%
rename from client/src/main/proto/spine/client/client_service.proto
rename to client/src/main/proto/spine/client/subscription_service.proto
index 8c4a1da3ffd..5a501f0c22a 100644
--- a/client/src/main/proto/spine/client/client_service.proto
+++ b/client/src/main/proto/spine/client/subscription_service.proto
@@ -22,36 +22,36 @@ syntax = "proto3";
 package spine.client;
 
 option (type_url_prefix) = "type.spine3.org";
-// We put gRPC-based classes into `grpc` sub-package, which is annotated as `@Internal`
-// to hide implementation details from the public API of the framework.
 option java_package = "org.spine3.client.grpc";
 option java_multiple_files = true;
-option java_outer_classname = "ClientServiceProto";
+option java_outer_classname = "SubscriptionServiceProto";
 option java_generate_equals_and_hash = true;
 
+
 import "spine/annotations.proto";
-import "spine/base/command.proto";
-import "spine/base/event.proto";
+import "spine/client/subscription.proto";
 import "spine/base/response.proto";
 
-// The topic of interest the client can subscribe and unsubscribe.
-message Topic {
-    //TODO:2016-01-14:alexander.yevsyukov: Define this type. E.g. there can be some structure, which describes many
-    // points of interest at once. See Pub-sub for possible API inspiration. Chances are it's going to be one of underlying
-    // implementations.
-    string value = 1;
-}
+// A service for subscribing to the read-side changes by clients.
+service SubscriptionService {
+
+    // Create the subscription to the particular read-side updates.
+    //
+    // Topic defines the target of subscription and other attributes (like field masks).
+    // NOTE: this method serves for Topic creation; to start listening for updates use #Activate(Subscription).
+    rpc Subscribe (Topic) returns (Subscription);
 
-// The service for sending commands from clients.
-service ClientService {
 
-    // The request to handle a command.
-    rpc Post(base.Command) returns (base.Response);
+    // Activate the subscription to the particular read-side updates.
+    //
+    // The client will start receiving the subscription updates upon new topic target changes in the read-side.
+    // Cancelled subscriptions cannot be activated.
+    rpc Activate(Subscription) returns (stream SubscriptionUpdate);
 
-    // The request to receive events on the topic of interest.
-    rpc Subscribe(Topic) returns (stream base.Event);
 
-    // The request to unsubscribe from the topic.
-    // This should close the stream opened by `Subscribe` call with the same `Topic` value.
-    rpc Unsubscribe(Topic) returns (base.Response);
+    // Cancel the given subscription.
+    //
+    // Clients will stop receiving the SubscriptionUpdate after this method is called.
+    // The subscription is destroyed as a result of invocation.
+    rpc Cancel (Subscription) returns (base.Response);
 }
diff --git a/client/src/test/java/org/spine3/base/QueriesShould.java b/client/src/test/java/org/spine3/base/QueriesShould.java
new file mode 100644
index 00000000000..0a711325774
--- /dev/null
+++ b/client/src/test/java/org/spine3/base/QueriesShould.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.base;
+
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.ProtocolStringList;
+import org.junit.Test;
+import org.spine3.client.EntityFilters;
+import org.spine3.client.EntityId;
+import org.spine3.client.EntityIdFilter;
+import org.spine3.client.Query;
+import org.spine3.client.Target;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.test.queries.TestEntity;
+import org.spine3.test.queries.TestEntityId;
+
+import java.util.List;
+import java.util.Set;
+
+import static com.google.common.collect.Sets.newHashSet;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.spine3.test.Tests.hasPrivateUtilityConstructor;
+
+/**
+ * @author Alex Tymchenko
+ */
+@SuppressWarnings({"LocalVariableNamingConvention", "MagicNumber", "MethodParameterNamingConvention"})
+public class QueriesShould {
+
+    // See {@code queries_should.proto} for declaration.
+    private static final Class<TestEntity> TARGET_ENTITY_CLASS = TestEntity.class;
+    private static final String TARGET_ENTITY_TYPE_URL = "type.spine3.org/spine.test.queries.TestEntity";
+
+    @Test
+    public void have_private_constructor() {
+        assertTrue(hasPrivateUtilityConstructor(Queries.class));
+    }
+
+    @Test
+    public void have_private_constructor_of_targets_class() {
+        assertTrue(hasPrivateUtilityConstructor(Queries.Targets.class));
+    }
+
+    @Test
+    public void compose_proper_read_all_query() {
+        final Class<TestEntity> targetEntityClass = TestEntity.class;
+        final Query readAllQuery = Queries.readAll(targetEntityClass);
+        assertNotNull(readAllQuery);
+
+        checkTypeCorrectAndFiltersEmpty(targetEntityClass, readAllQuery);
+
+        checkFieldMaskEmpty(readAllQuery);
+    }
+
+    @Test
+    public void compose_proper_read_all_query_with_single_path() {
+        final Class<TestEntity> targetEntityClass = TestEntity.class;
+        final String expectedEntityPath = singleTestEntityPath();
+        final Query readAllWithPathFilteringQuery = Queries.readAll(targetEntityClass, expectedEntityPath);
+        assertNotNull(readAllWithPathFilteringQuery);
+
+        checkTypeCorrectAndFiltersEmpty(targetEntityClass, readAllWithPathFilteringQuery);
+        verifySinglePathInQuery(expectedEntityPath, readAllWithPathFilteringQuery);
+    }
+
+    @Test
+    public void compose_proper_read_all_query_with_multiple_random_paths() {
+        final Class<TestEntity> targetEntityClass = TestEntity.class;
+
+        final String[] paths = multipleRandomPaths();
+        final Query readAllWithPathFilteringQuery = Queries.readAll(targetEntityClass, paths);
+        assertNotNull(readAllWithPathFilteringQuery);
+
+        checkTypeCorrectAndFiltersEmpty(targetEntityClass, readAllWithPathFilteringQuery);
+        verifyMultiplePathsInQuery(paths, readAllWithPathFilteringQuery);
+    }
+
+    @Test
+    public void compose_proper_read_by_ids_query() {
+        final Set<TestEntityId> testEntityIds = multipleIds();
+        final Query readByIdsQuery = Queries.readByIds(TARGET_ENTITY_CLASS, testEntityIds);
+        assertNotNull(readByIdsQuery);
+
+        checkFieldMaskEmpty(readByIdsQuery);
+
+        final Target target = checkTarget(TARGET_ENTITY_CLASS, readByIdsQuery);
+
+        verifyIdFilter(testEntityIds, target.getFilters());
+    }
+
+    @Test
+    public void compose_proper_read_by_ids_query_with_single_path() {
+        final Set<TestEntityId> testEntityIds = multipleIds();
+        final String expectedPath = singleTestEntityPath();
+        final Query readByIdsWithSinglePathQuery = Queries.readByIds(
+                TARGET_ENTITY_CLASS,
+                testEntityIds,
+                expectedPath);
+        assertNotNull(readByIdsWithSinglePathQuery);
+
+        final Target target = checkTarget(TARGET_ENTITY_CLASS, readByIdsWithSinglePathQuery);
+
+        verifyIdFilter(testEntityIds, target.getFilters());
+        verifySinglePathInQuery(expectedPath, readByIdsWithSinglePathQuery);
+    }
+
+    @Test
+    public void compose_proper_read_by_ids_query_with_multiple_random_paths() {
+        final Set<TestEntityId> testEntityIds = multipleIds();
+        final String[] paths = multipleRandomPaths();
+        final Query readByIdsWithSinglePathQuery = Queries.readByIds(
+                TARGET_ENTITY_CLASS,
+                testEntityIds,
+                paths);
+        assertNotNull(readByIdsWithSinglePathQuery);
+
+        final Target target = checkTarget(TARGET_ENTITY_CLASS, readByIdsWithSinglePathQuery);
+
+        verifyIdFilter(testEntityIds, target.getFilters());
+        verifyMultiplePathsInQuery(paths, readByIdsWithSinglePathQuery);
+    }
+
+    @Test
+    public void return_proper_type_for_known_target() {
+        final Target target = Queries.Targets.allOf(TARGET_ENTITY_CLASS);
+        final Query query = Query.newBuilder()
+                                 .setTarget(target)
+                                 .build();
+        final TypeUrl type = Queries.typeOf(query);
+        assertNotNull(type);
+        assertEquals(TARGET_ENTITY_TYPE_URL, type.toString());
+    }
+
+    @Test
+    public void return_null_if_target_type_unknown() {
+        final Target target = Target.newBuilder()
+                                    .setType("Inexistent Message Type")
+                                    .build();
+        final Query query = Query.newBuilder()
+                                 .setTarget(target)
+                                 .build();
+        final TypeUrl type = Queries.typeOf(query);
+        assertNull(type);
+    }
+
+    private static void verifyMultiplePathsInQuery(String[] paths, Query readAllWithPathFilteringQuery) {
+        final FieldMask fieldMask = readAllWithPathFilteringQuery.getFieldMask();
+        assertEquals(paths.length, fieldMask.getPathsCount());
+        final ProtocolStringList pathsList = fieldMask.getPathsList();
+        for (String expectedPath : paths) {
+            assertTrue(pathsList.contains(expectedPath));
+        }
+    }
+
+    private static void verifySinglePathInQuery(String expectedEntityPath, Query query) {
+        final FieldMask fieldMask = query.getFieldMask();
+        assertEquals(1, fieldMask.getPathsCount());     // as we set the only path value.
+
+        final String firstPath = fieldMask.getPaths(0);
+        assertEquals(expectedEntityPath, firstPath);
+    }
+
+    private static String[] multipleRandomPaths() {
+        return new String[]{"some", "random", "paths"};
+    }
+
+    private static String singleTestEntityPath() {
+        return TestEntity.getDescriptor()
+                         .getFields()
+                         .get(1)
+                         .getFullName();
+    }
+
+    private static Set<TestEntityId> multipleIds() {
+        return newHashSet(TestEntityId.newBuilder()
+                                      .setValue(1)
+                                      .build(),
+                          TestEntityId.newBuilder()
+                                      .setValue(7)
+                                      .build(),
+                          TestEntityId.newBuilder()
+                                      .setValue(15)
+                                      .build());
+    }
+
+    private static void verifyIdFilter(Set<TestEntityId> expectedIds, EntityFilters filters) {
+        assertNotNull(filters);
+        final EntityIdFilter idFilter = filters.getIdFilter();
+        assertNotNull(idFilter);
+        final List<EntityId> actualListOfIds = idFilter.getIdsList();
+        for (TestEntityId testEntityId : expectedIds) {
+            final EntityId expectedEntityId = EntityId.newBuilder()
+                                                      .setId(AnyPacker.pack(testEntityId))
+                                                      .build();
+            assertTrue(actualListOfIds.contains(expectedEntityId));
+        }
+    }
+
+    private static void checkFieldMaskEmpty(Query query) {
+        final FieldMask fieldMask = query.getFieldMask();
+        assertNotNull(fieldMask);
+        assertEquals(FieldMask.getDefaultInstance(), fieldMask);
+    }
+
+    private static void checkTypeCorrectAndFiltersEmpty(Class<TestEntity> expectedTargetClass, Query query) {
+        final Target entityTarget = checkTarget(expectedTargetClass, query);
+
+        final EntityFilters filters = entityTarget.getFilters();
+        assertNotNull(filters);
+        assertEquals(EntityFilters.getDefaultInstance(), filters);
+    }
+
+    private static Target checkTarget(Class<TestEntity> targetEntityClass, Query query) {
+        final Target entityTarget = query.getTarget();
+        assertNotNull(entityTarget);
+
+        final String expectedTypeName = TypeUrl.of(targetEntityClass)
+                                               .getTypeName();
+        assertEquals(expectedTypeName, entityTarget.getType());
+        return entityTarget;
+    }
+}
diff --git a/client/src/test/java/org/spine3/validate/ValidateShould.java b/client/src/test/java/org/spine3/validate/ValidateShould.java
index acbf3aea744..1fd88bb7c2a 100644
--- a/client/src/test/java/org/spine3/validate/ValidateShould.java
+++ b/client/src/test/java/org/spine3/validate/ValidateShould.java
@@ -81,34 +81,34 @@ public void return_non_default_value_on_check() {
 
     @Test(expected = IllegalArgumentException.class)
     public void throw_exception_if_timestamp_seconds_value_is_zero() {
-        Validate.checkIsPositive(Timestamp.newBuilder()
-                                          .setSeconds(0)
-                                          .setNanos(5)
-                                          .build(), "");
+        Validate.checkPositive(Timestamp.newBuilder()
+                                        .setSeconds(0)
+                                        .setNanos(5)
+                                        .build(), "");
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void throw_exception_if_timestamp_seconds_value_is_negative() {
-        Validate.checkIsPositive(Timestamp.newBuilder()
-                                          .setSeconds(-5)
-                                          .setNanos(5)
-                                          .build(), "");
+        Validate.checkPositive(Timestamp.newBuilder()
+                                        .setSeconds(-5)
+                                        .setNanos(5)
+                                        .build(), "");
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void throw_exception_if_timestamp_nanos_value_is_negative() {
-        Validate.checkIsPositive(Timestamp.newBuilder()
-                                          .setSeconds(5)
-                                          .setNanos(-5)
-                                          .build(), "");
+        Validate.checkPositive(Timestamp.newBuilder()
+                                        .setSeconds(5)
+                                        .setNanos(-5)
+                                        .build(), "");
     }
 
     @Test
     public void do_not_throw_exception_if_timestamp_seconds_and_nanos_are_positive() {
-        Validate.checkIsPositive(Timestamp.newBuilder()
-                                          .setSeconds(5)
-                                          .setNanos(5)
-                                          .build(), "");
+        Validate.checkPositive(Timestamp.newBuilder()
+                                        .setSeconds(5)
+                                        .setNanos(5)
+                                        .build(), "");
     }
 
     @Test(expected = NullPointerException.class)
diff --git a/client/src/test/proto/spine/test/queries_should.proto b/client/src/test/proto/spine/test/queries_should.proto
new file mode 100644
index 00000000000..ec38a46decd
--- /dev/null
+++ b/client/src/test/proto/spine/test/queries_should.proto
@@ -0,0 +1,50 @@
+//
+// Copyright 2016, TeamDev Ltd. All rights reserved.
+//
+// Redistribution and use in source and/or binary forms, with or without
+// modification, must retain the above copyright notice and the following
+// disclaimer.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+syntax = "proto3";
+
+package spine.test.queries;
+
+option (type_url_prefix) = "type.spine3.org";
+option java_package="org.spine3.test.queries";
+option java_multiple_files = true;
+option java_outer_classname = "QueriesShouldProto";
+
+
+import "spine/annotations.proto";
+
+// Only for usage in `QueriesShould` class.
+
+// Simple ID for tests.
+message TestEntityId {
+
+    // Numeric value wrapped into this ID.
+    int32 value = 1;
+}
+
+// Test entity used as a `Target` for queries.
+message TestEntity {
+
+    // Entity ID.
+    TestEntityId id = 1;
+
+    string first_field = 2;
+
+    bool second_field = 3;
+}
diff --git a/examples/build.gradle b/examples/build.gradle
new file mode 100644
index 00000000000..4a0ed672fc7
--- /dev/null
+++ b/examples/build.gradle
@@ -0,0 +1,13 @@
+dependencies {
+    compile project(path: ':client')
+    compile project(path: ':server')
+    //Use jdk14 bindings for the sample application
+    compile group: 'org.slf4j', name: 'slf4j-jdk14', version: project.slf4JVersion
+}
+
+sourceSets.main.java.srcDir generatedSpineDir
+
+apply from: generateDescriptorSetPlugin
+
+apply plugin: spineProtobufPluginId
+
diff --git a/examples/src/main/java/org/spine3/examples/aggregate/ClientApp.java b/examples/src/main/java/org/spine3/examples/aggregate/ClientApp.java
new file mode 100644
index 00000000000..7a1d2d53335
--- /dev/null
+++ b/examples/src/main/java/org/spine3/examples/aggregate/ClientApp.java
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.examples.aggregate;
+
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.stub.StreamObserver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spine3.base.Command;
+import org.spine3.base.Identifiers;
+import org.spine3.base.Queries;
+import org.spine3.base.Response;
+import org.spine3.client.CommandFactory;
+import org.spine3.client.Subscription;
+import org.spine3.client.SubscriptionUpdate;
+import org.spine3.client.Target;
+import org.spine3.client.Topic;
+import org.spine3.client.grpc.CommandServiceGrpc;
+import org.spine3.client.grpc.SubscriptionServiceGrpc;
+import org.spine3.examples.aggregate.command.AddOrderLine;
+import org.spine3.examples.aggregate.command.CreateOrder;
+import org.spine3.examples.aggregate.command.PayForOrder;
+import org.spine3.money.Money;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.Messages;
+import org.spine3.time.ZoneOffsets;
+
+import java.util.List;
+
+import static com.google.common.collect.Lists.newLinkedList;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.spine3.client.ConnectionConstants.DEFAULT_CLIENT_SERVICE_PORT;
+import static org.spine3.client.UserUtil.newUserId;
+import static org.spine3.money.Currency.USD;
+import static org.spine3.money.MoneyUtil.newMoney;
+import static org.spine3.protobuf.Messages.toText;
+
+/**
+ * Sample of a client implementation.
+ *
+ * @author Mikhail Melnik
+ * @author Mikhail Mikhaylov
+ * @author Alexander Litus
+ */
+@SuppressWarnings("OverlyCoupledClass")     // OK for a self-contained all-in-one example.
+public class ClientApp {
+
+    @SuppressWarnings("DuplicateStringLiteralInspection")
+    private static final String SERVICE_HOST = "localhost";
+
+    private static final String RPC_FAILED = "RPC failed";
+    private static final int SHUTDOWN_TIMEOUT_SEC = 5;
+
+    private final CommandFactory commandFactory;
+    private final ManagedChannel channel;
+    private final CommandServiceGrpc.CommandServiceBlockingStub blockingClient;
+    private final SubscriptionServiceGrpc.SubscriptionServiceStub subscriptionClient;
+
+    private final StreamObserver<SubscriptionUpdate> orderUpdateObserver = new StreamObserver<SubscriptionUpdate>() {
+        @Override
+        public void onNext(SubscriptionUpdate subscriptionUpdate) {
+            final String updateText = Messages.toText(subscriptionUpdate);
+            log().info(" + Order updated: {}", updateText);
+        }
+
+        @Override
+        public void onError(Throwable throwable) {
+            log().error("Subscription update delivery error occurred", throwable);
+        }
+
+        @Override
+        public void onCompleted() {
+            log().info("Subscription update delivery completed.");
+        }
+    };
+
+
+    /** Construct the client connecting to server at {@code host:port}. */
+    public ClientApp(String host, int port) {
+        commandFactory = CommandFactory.newBuilder()
+                                       .setActor(newUserId(Identifiers.newUuid()))
+                                       .setZoneOffset(ZoneOffsets.UTC)
+                                       .build();
+        channel = ManagedChannelBuilder
+                .forAddress(host, port)
+                .usePlaintext(true)
+                .build();
+        blockingClient = CommandServiceGrpc.newBlockingStub(channel);
+        subscriptionClient = SubscriptionServiceGrpc.newStub(channel);
+    }
+
+    private Command createOrder(OrderId orderId) {
+        final CreateOrder msg = CreateOrder.newBuilder()
+                                           .setOrderId(orderId)
+                                           .build();
+        return commandFactory.create(msg);
+    }
+
+    private Command addOrderLine(OrderId orderId) {
+        final int bookPriceUsd = 52;
+        final Book book = Book.newBuilder()
+                              .setBookId(BookId.newBuilder()
+                                               .setISBN("978-0321125217")
+                                               .build())
+                              .setAuthor("Eric Evans")
+                              .setTitle("Domain Driven Design.")
+                              .setPrice(newMoney(bookPriceUsd, USD))
+                              .build();
+        final int quantity = 1;
+        final Money totalPrice = newMoney(bookPriceUsd * quantity, USD);
+        final OrderLine orderLine = OrderLine.newBuilder()
+                                             .setProductId(AnyPacker.pack(book.getBookId()))
+                                             .setQuantity(quantity)
+                                             .setPrice(totalPrice)
+                                             .build();
+        final AddOrderLine msg = AddOrderLine.newBuilder()
+                                             .setOrderId(orderId)
+                                             .setOrderLine(orderLine)
+                                             .build();
+        return commandFactory.create(msg);
+    }
+
+    private Command payForOrder(OrderId orderId) {
+        final BillingInfo billingInfo = BillingInfo.newBuilder()
+                                                   .setInfo("Payment info is here.")
+                                                   .build();
+        final PayForOrder msg = PayForOrder.newBuilder()
+                                           .setOrderId(orderId)
+                                           .setBillingInfo(billingInfo)
+                                           .build();
+        return commandFactory.create(msg);
+    }
+
+
+    private void subscribe() {
+        final Target allOrders = Queries.Targets.allOf(Order.class);
+        final Topic topic = Topic.newBuilder()
+                                 .setTarget(allOrders)
+                                 .build();
+        subscriptionClient.subscribe(topic, new StreamObserver<Subscription>() {
+
+            private Subscription latestSubscription;
+
+            @Override
+            public void onNext(Subscription subscription) {
+                this.latestSubscription = subscription;
+                final String eventText = Messages.toText(subscription);
+                log().info(eventText);
+            }
+
+            @Override
+            public void onError(Throwable throwable) {
+                log().error("Subscription error occurred", throwable);
+            }
+
+            @Override
+            public void onCompleted() {
+                log().info("Subscription request completed.");
+                subscriptionClient.activate(latestSubscription, orderUpdateObserver);
+            }
+
+        });
+    }
+
+
+    /** Sends requests to the server. */
+    public static void main(String[] args) throws InterruptedException {
+        final ClientApp client = new ClientApp(SERVICE_HOST, DEFAULT_CLIENT_SERVICE_PORT);
+        client.subscribe();
+
+        final List<Command> requests = client.generateRequests();
+
+        for (Command request : requests) {
+            log().info("Sending a request: " + request.getMessage()
+                                                      .getTypeUrl() + "...");
+            final Response result = client.post(request);
+            log().info("Result: " + toText(result));
+        }
+
+        client.shutdown();
+    }
+
+    /** Creates several test requests. */
+    private List<Command> generateRequests() {
+        final List<Command> result = newLinkedList();
+        for (int i = 0; i < 10; i++) {
+            final OrderId orderId = OrderId.newBuilder()
+                                           .setValue(String.valueOf(i))
+                                           .build();
+            result.add(createOrder(orderId));
+            result.add(addOrderLine(orderId));
+            result.add(payForOrder(orderId));
+        }
+        return result;
+    }
+
+    /**
+     * Shutdown the connection channel.
+     *
+     * @throws InterruptedException if waiting is interrupted.
+     */
+    private void shutdown() throws InterruptedException {
+        channel.shutdown()
+               .awaitTermination(SHUTDOWN_TIMEOUT_SEC, SECONDS);
+    }
+
+    /** Sends a request to the server. */
+    private Response post(Command request) {
+        Response result = null;
+        try {
+            result = blockingClient.post(request);
+        } catch (RuntimeException e) {
+            log().warn(RPC_FAILED, e);
+        }
+        return result;
+    }
+
+    private enum LogSingleton {
+        INSTANCE;
+        @SuppressWarnings("NonSerializableFieldInSerializableClass")
+        private final Logger value = LoggerFactory.getLogger(ClientApp.class);
+    }
+
+    private static Logger log() {
+        return LogSingleton.INSTANCE.value;
+    }
+}
diff --git a/examples/src/main/java/org/spine3/examples/aggregate/server/Server.java b/examples/src/main/java/org/spine3/examples/aggregate/server/Server.java
new file mode 100644
index 00000000000..85412371d97
--- /dev/null
+++ b/examples/src/main/java/org/spine3/examples/aggregate/server/Server.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.examples.aggregate.server;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spine3.server.BoundedContext;
+import org.spine3.server.CommandService;
+import org.spine3.server.SubscriptionService;
+import org.spine3.server.event.EventSubscriber;
+import org.spine3.server.storage.StorageFactory;
+import org.spine3.server.storage.memory.InMemoryStorageFactory;
+import org.spine3.server.transport.GrpcContainer;
+
+import java.io.IOException;
+
+import static org.spine3.client.ConnectionConstants.DEFAULT_CLIENT_SERVICE_PORT;
+
+/**
+ * Sample gRPC server implementation.
+ *
+ * @author Mikhail Melnik
+ * @author Alexander Litus
+ */
+public class Server {
+
+    private final GrpcContainer grpcContainer;
+    private final BoundedContext boundedContext;
+
+    public Server(StorageFactory storageFactory) {
+        // Create a bounded context.
+        this.boundedContext = BoundedContext.newBuilder()
+                                            .setStorageFactory(storageFactory)
+                                            .build();
+        // Create and register a repository with the bounded context.
+        final OrderRepository repository = new OrderRepository(boundedContext);
+        boundedContext.register(repository);
+
+        // Subscribe an event subscriber in the bounded context.
+        final EventSubscriber eventLogger = new EventLogger();
+        boundedContext.getEventBus()
+                      .subscribe(eventLogger);
+
+        // Create a command service with this bounded context,
+        final CommandService commandService = CommandService.newBuilder()
+                                                           .addBoundedContext(boundedContext)
+                                                           .build();
+
+        // and a subscription service for the same bounded context.
+        final SubscriptionService subscriptionService = SubscriptionService.newBuilder()
+                                                                .addBoundedContext(boundedContext)
+                                                                .build();
+
+
+        // Create a gRPC server and schedule the client service instance for deployment.
+        this.grpcContainer = GrpcContainer.newBuilder()
+                                          .setPort(DEFAULT_CLIENT_SERVICE_PORT)
+                                          .addService(commandService)
+                                          .addService(subscriptionService)
+                                          .build();
+    }
+
+    public void start() throws IOException {
+        grpcContainer.start();
+        grpcContainer.addShutdownHook();
+        log().info("Server started, listening to commands on the port " + DEFAULT_CLIENT_SERVICE_PORT);
+    }
+
+    public void awaitTermination() {
+        grpcContainer.awaitTermination();
+    }
+
+    public void shutdown() throws Exception {
+        grpcContainer.shutdown();
+        boundedContext.close();
+    }
+
+    /** The entry point of the server application. */
+    public static void main(String[] args) throws IOException {
+        final Server server = new Server(InMemoryStorageFactory.getInstance());
+        server.start();
+        server.awaitTermination();
+    }
+
+    private static Logger log() {
+        return LogSingleton.INSTANCE.value;
+    }
+
+    private enum LogSingleton {
+        INSTANCE;
+        @SuppressWarnings("NonSerializableFieldInSerializableClass")
+        private final Logger value = LoggerFactory.getLogger(Server.class);
+    }
+}
diff --git a/examples/src/test/java/org/spine3/examples/aggregate/server/ServerShould.java b/examples/src/test/java/org/spine3/examples/aggregate/server/ServerShould.java
new file mode 100644
index 00000000000..d6cb30c5898
--- /dev/null
+++ b/examples/src/test/java/org/spine3/examples/aggregate/server/ServerShould.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.examples.aggregate.server;
+
+import org.junit.Test;
+import org.spine3.examples.aggregate.ClientApp;
+import org.spine3.server.storage.memory.InMemoryStorageFactory;
+
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static com.google.common.base.Throwables.propagate;
+
+@SuppressWarnings("InstanceMethodNamingConvention")
+public class ServerShould {
+
+    @Test
+    public void run_on_in_memory_storage() throws Exception {
+        final Server[] serverRef = new Server[1];
+        final CountDownLatch serverStartLatch = new CountDownLatch(1);
+
+        final Thread serverThread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                final Server server = new Server(InMemoryStorageFactory.getInstance());
+                serverRef[0] = server;
+                try {
+                    server.start();
+                    server.awaitTermination();
+                    serverStartLatch.countDown();
+                } catch (IOException e) {
+                    throw propagate(e);
+                }
+            }
+        });
+
+        serverThread.start();
+
+        serverStartLatch.await(5, TimeUnit.SECONDS);
+        //noinspection ZeroLengthArrayAllocation
+        ClientApp.main(new String[0]);
+
+        serverRef[0].shutdown();
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/BoundedContext.java b/server/src/main/java/org/spine3/server/BoundedContext.java
index 46b78d3fc44..dd4bb7b1095 100644
--- a/server/src/main/java/org/spine3/server/BoundedContext.java
+++ b/server/src/main/java/org/spine3/server/BoundedContext.java
@@ -43,6 +43,9 @@
 import org.spine3.server.integration.IntegrationEvent;
 import org.spine3.server.integration.IntegrationEventContext;
 import org.spine3.server.integration.grpc.IntegrationEventSubscriberGrpc;
+import org.spine3.server.stand.Stand;
+import org.spine3.server.stand.StandFunnel;
+import org.spine3.server.storage.StandStorage;
 import org.spine3.server.storage.StorageFactory;
 import org.spine3.validate.Validate;
 
@@ -64,7 +67,7 @@
  * @author Mikhail Melnik
  */
 public class BoundedContext extends IntegrationEventSubscriberGrpc.IntegrationEventSubscriberImplBase
-                            implements AutoCloseable {
+        implements AutoCloseable {
 
     /** The default name for a {@code BoundedContext}. */
     public static final String DEFAULT_NAME = "Main";
@@ -80,6 +83,8 @@ public class BoundedContext extends IntegrationEventSubscriberGrpc.IntegrationEv
     private final StorageFactory storageFactory;
     private final CommandBus commandBus;
     private final EventBus eventBus;
+    private final Stand stand;
+    private final StandFunnel standFunnel;
 
     private final List<Repository<?, ?>> repositories = Lists.newLinkedList();
 
@@ -89,6 +94,8 @@ private BoundedContext(Builder builder) {
         this.storageFactory = builder.storageFactory;
         this.commandBus = builder.commandBus;
         this.eventBus = builder.eventBus;
+        this.stand = builder.stand;
+        this.standFunnel = builder.standFunnel;
     }
 
     /**
@@ -110,6 +117,7 @@ public static Builder newBuilder() {
      * <li>Closes {@link EventBus}.
      * <li>Closes {@link CommandStore}.
      * <li>Closes {@link EventStore}.
+     * <li>Closes {@link Stand}.
      * <li>Shuts down all registered repositories. Each registered repository is:
      *      <ul>
      *      <li>un-registered from {@link CommandBus}
@@ -125,6 +133,7 @@ public void close() throws Exception {
         storageFactory.close();
         commandBus.close();
         eventBus.close();
+        stand.close();
 
         shutDownRepositories();
 
@@ -183,6 +192,7 @@ public boolean isMultitenant() {
         if (repository instanceof EventDispatcher) {
             eventBus.register((EventDispatcher) repository);
         }
+        stand.registerTypeSupplier(repository);
     }
 
     private void checkStorageAssigned(Repository repository) {
@@ -207,10 +217,10 @@ private static Event toEvent(IntegrationEvent integrationEvent) {
         final IntegrationEventContext sourceContext = integrationEvent.getContext();
         final StringValue producerId = newStringValue(sourceContext.getBoundedContextName());
         final EventContext context = EventContext.newBuilder()
-                .setEventId(sourceContext.getEventId())
-                .setTimestamp(sourceContext.getTimestamp())
-                .setProducerId(AnyPacker.pack(producerId))
-                .build();
+                                                 .setEventId(sourceContext.getEventId())
+                                                 .setTimestamp(sourceContext.getTimestamp())
+                                                 .setProducerId(AnyPacker.pack(producerId))
+                                                 .build();
         final Event result = Events.createEvent(integrationEvent.getMessage(), context);
         return result;
     }
@@ -227,6 +237,18 @@ public EventBus getEventBus() {
         return this.eventBus;
     }
 
+    /** Obtains instance of {@link StandFunnel} of this {@code BoundedContext}. */
+    @CheckReturnValue
+    public StandFunnel getStandFunnel() {
+        return this.standFunnel;
+    }
+
+    /** Obtains instance of {@link Stand} of this {@code BoundedContext}. */
+    @CheckReturnValue
+    public Stand getStand() {
+        return stand;
+    }
+
     /**
      * A builder for producing {@code BoundedContext} instances.
      *
@@ -244,6 +266,9 @@ public static class Builder {
         private EventBus eventBus;
         private boolean multitenant;
         private EventEnricher eventEnricher;
+        private Stand stand;
+        private StandFunnel standFunnel;
+        private Executor standFunnelExecutor;
 
         /**
          * Sets the name for a new bounded context.
@@ -371,6 +396,26 @@ public EventEnricher getEventEnricher() {
             return eventEnricher;
         }
 
+        public Builder setStand(Stand stand) {
+            this.stand = checkNotNull(stand);
+            return this;
+        }
+
+        @Nullable
+        public Stand getStand() {
+            return stand;
+        }
+
+        @Nullable
+        public Executor getStandFunnelExecutor() {
+            return standFunnelExecutor;
+        }
+
+        public Builder setStandFunnelExecutor(Executor standFunnelExecutor) {
+            this.standFunnelExecutor = standFunnelExecutor;
+            return this;
+        }
+
         public BoundedContext build() {
             checkNotNull(storageFactory, "storageFactory must be set");
 
@@ -388,6 +433,12 @@ public BoundedContext build() {
                 eventBus = createEventBus();
             }
 
+            if (stand == null) {
+                stand = createStand(storageFactory);
+            }
+
+            standFunnel = createStandFunnel(standFunnelExecutor);
+
             commandBus.setMultitenant(this.multitenant);
 
             final BoundedContext result = new BoundedContext(this);
@@ -396,6 +447,21 @@ public BoundedContext build() {
             return result;
         }
 
+        private StandFunnel createStandFunnel(@Nullable Executor standFunnelExecutor) {
+            StandFunnel standFunnel;
+            if (standFunnelExecutor == null) {
+                standFunnel = StandFunnel.newBuilder()
+                                         .setStand(stand)
+                                         .build();
+            } else {
+                standFunnel = StandFunnel.newBuilder()
+                                         .setExecutor(standFunnelExecutor)
+                                         .setStand(stand)
+                                         .build();
+            }
+            return standFunnel;
+        }
+
         private CommandStore createCommandStore() {
             final CommandStore result = new CommandStore(storageFactory.createCommandStorage());
             return result;
@@ -432,6 +498,14 @@ private EventBus createEventBus() {
                                             .build();
             return result;
         }
+
+        private static Stand createStand(StorageFactory storageFactory) {
+            final StandStorage standStorage = storageFactory.createStandStorage();
+            final Stand result = Stand.newBuilder()
+                                      .setStorage(standStorage)
+                                      .build();
+            return result;
+        }
     }
 
     private enum LogSingleton {
diff --git a/server/src/main/java/org/spine3/server/ClientService.java b/server/src/main/java/org/spine3/server/ClientService.java
deleted file mode 100644
index 1797d36da44..00000000000
--- a/server/src/main/java/org/spine3/server/ClientService.java
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * Copyright 2016, TeamDev Ltd. All rights reserved.
- *
- * Redistribution and use in source and/or binary forms, with or without
- * modification, must retain the above copyright notice and the following
- * disclaimer.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package org.spine3.server;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Sets;
-import io.grpc.ServerBuilder;
-import io.grpc.ServerServiceDefinition;
-import io.grpc.stub.StreamObserver;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.spine3.base.Command;
-import org.spine3.base.Event;
-import org.spine3.base.Response;
-import org.spine3.base.Responses;
-import org.spine3.client.ConnectionConstants;
-import org.spine3.client.grpc.Topic;
-import org.spine3.server.command.error.CommandException;
-import org.spine3.server.command.error.UnsupportedCommandException;
-import org.spine3.server.type.CommandClass;
-
-import javax.annotation.Nullable;
-import java.io.IOException;
-import java.util.Set;
-
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.base.Throwables.propagate;
-
-/**
- * The {@code ClientService} allows client applications to post commands and
- * receive updates from the application backend.
- *
- * @author Alexander Yevsyukov
- */
-public class ClientService extends org.spine3.client.grpc.ClientServiceGrpc.ClientServiceImplBase {
-
-    private static final String SERVICE_NOT_STARTED_MSG = "Service was not started or is shutdown already.";
-
-    private final int port;
-
-    private final ImmutableMap<CommandClass, BoundedContext> boundedContextMap;
-
-    @Nullable
-    private io.grpc.Server grpcServer;
-
-    public static Builder newBuilder() {
-        return new Builder();
-    }
-
-    protected ClientService(Builder builder) {
-        this.port = builder.getPort();
-        this.boundedContextMap = builder.getBoundedContextMap();
-    }
-
-    /**
-     * Starts the service.
-     *
-     * @throws IOException if unable to bind
-     */
-    public void start() throws IOException {
-        checkState(grpcServer == null, "Service is started already.");
-        grpcServer = createGrpcServer(port);
-        grpcServer.start();
-    }
-
-    /** Waits for the service to become terminated. */
-    public void awaitTermination() {
-        checkState(grpcServer != null, SERVICE_NOT_STARTED_MSG);
-        try {
-            grpcServer.awaitTermination();
-        } catch (InterruptedException e) {
-            throw propagate(e);
-        }
-    }
-
-    /**
-     * Makes the JVM shut down the service when it is shutting down itself.
-     *
-     * <p>Call this method when running the service in a separate JVM.
-     */
-    public void addShutdownHook() {
-        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
-            // Use stderr here since the logger may have been reset by its JVM shutdown hook.
-            @SuppressWarnings("UseOfSystemOutOrSystemErr")
-            @Override
-            public void run() {
-                final String serviceClass = ClientService.this.getClass().getName();
-                try {
-                    if (!isShutdown()) {
-                        System.err.println("Shutting down " + serviceClass + " since JVM is shutting down...");
-                        shutdown();
-                        System.err.println(serviceClass + " shut down.");
-                    }
-                } catch (RuntimeException e) {
-                    e.printStackTrace(System.err);
-                }
-            }
-        }));
-    }
-
-    /**
-     * Returns {@code true} if the service is shutdown or was not started at all, {@code false} otherwise.
-     *
-     * @see ClientService#shutdown()
-     */
-    public boolean isShutdown() {
-        final boolean isShutdown = grpcServer == null;
-        return isShutdown;
-    }
-
-    /** Initiates an orderly shutdown in which existing calls continue but new calls are rejected. */
-    public void shutdown() {
-        checkState(grpcServer != null, SERVICE_NOT_STARTED_MSG);
-        grpcServer.shutdown();
-        grpcServer = null;
-    }
-
-    @VisibleForTesting
-    /* package */ io.grpc.Server createGrpcServer(int port) {
-        final ServerServiceDefinition service = bindService();
-        final ServerBuilder builder = ServerBuilder.forPort(port)
-                                                   .addService(service);
-        return builder.build();
-    }
-
-    @SuppressWarnings("RefusedBequest") // as we override default implementation with `unimplemented` status.
-    @Override
-    public void post(Command request, StreamObserver<Response> responseObserver) {
-        final CommandClass commandClass = CommandClass.of(request);
-        final BoundedContext boundedContext = boundedContextMap.get(commandClass);
-        if (boundedContext == null) {
-            handleUnsupported(request, responseObserver);
-        } else {
-            boundedContext.getCommandBus().post(request, responseObserver);
-        }
-    }
-
-    private static void handleUnsupported(Command request, StreamObserver<Response> responseObserver) {
-        final CommandException unsupported = new UnsupportedCommandException(request);
-        log().error("Unsupported command posted to ClientService", unsupported);
-        responseObserver.onError(Statuses.invalidArgumentWithCause(unsupported));
-    }
-
-    @SuppressWarnings("RefusedBequest") // as we override default implementation with `unimplemented` status.
-    @Override
-    public void subscribe(Topic request, StreamObserver<Event> responseObserver) {
-        //TODO:2016-05-25:alexander.yevsyukov: Subscribe the client to the topic in the corresponding BoundedContext.
-        // This API is likely to change to support Firebase-like registration where listening is
-        // done by the client SDK implementation.
-    }
-
-    @SuppressWarnings("RefusedBequest") // as we override default implementation with `unimplemented` status.
-    @Override
-    public void unsubscribe(Topic request, StreamObserver<Response> responseObserver) {
-        //TODO:2016-05-25:alexander.yevsyukov: Unsubscribe the client from the topic in the corresponding BoundedContext.
-        responseObserver.onNext(Responses.ok());
-        responseObserver.onCompleted();
-    }
-
-    public static class Builder {
-
-        private final Set<BoundedContext> boundedContexts = Sets.newHashSet();
-        private ImmutableMap<CommandClass, BoundedContext> boundedContextMap;
-
-        private int port = ConnectionConstants.DEFAULT_CLIENT_SERVICE_PORT;
-
-        public Builder addBoundedContext(BoundedContext boundedContext) {
-            // Save it to a temporary set so that it is easy to remove it if needed.
-            boundedContexts.add(boundedContext);
-            return this;
-        }
-
-        public Builder removeBoundedContext(BoundedContext boundedContext) {
-            boundedContexts.remove(boundedContext);
-            return this;
-        }
-
-        public Builder setPort(int port) {
-            this.port = port;
-            return this;
-        }
-
-        public int getPort() {
-            return this.port;
-        }
-
-        @SuppressWarnings("ReturnOfCollectionOrArrayField") // is immutable
-        public ImmutableMap<CommandClass, BoundedContext> getBoundedContextMap() {
-            return boundedContextMap;
-        }
-
-        /**
-         * Builds the {@link ClientService}.
-         * {@link ConnectionConstants#DEFAULT_CLIENT_SERVICE_PORT} is used by default.
-         */
-        public ClientService build() {
-            this.boundedContextMap = createBoundedContextMap();
-            final ClientService result = new ClientService(this);
-            return result;
-        }
-
-        private ImmutableMap<CommandClass, BoundedContext> createBoundedContextMap() {
-            final ImmutableMap.Builder<CommandClass, BoundedContext> builder = ImmutableMap.builder();
-            for (BoundedContext boundedContext : boundedContexts) {
-                addBoundedContext(builder, boundedContext);
-            }
-            return builder.build();
-        }
-
-        private static void addBoundedContext(ImmutableMap.Builder<CommandClass, BoundedContext> mapBuilder,
-                                              BoundedContext boundedContext) {
-            final Set<CommandClass> cmdClasses = boundedContext.getCommandBus().getSupportedCommandClasses();
-            for (CommandClass commandClass : cmdClasses) {
-                mapBuilder.put(commandClass, boundedContext);
-            }
-        }
-    }
-
-    private enum LogSingleton {
-        INSTANCE;
-        @SuppressWarnings("NonSerializableFieldInSerializableClass")
-        private final Logger value = LoggerFactory.getLogger(ClientService.class);
-    }
-
-    private static Logger log() {
-        return LogSingleton.INSTANCE.value;
-    }
-}
diff --git a/server/src/main/java/org/spine3/server/CommandService.java b/server/src/main/java/org/spine3/server/CommandService.java
new file mode 100644
index 00000000000..07b523a00a8
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/CommandService.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Sets;
+import io.grpc.stub.StreamObserver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spine3.base.Command;
+import org.spine3.base.Response;
+import org.spine3.client.grpc.CommandServiceGrpc;
+import org.spine3.server.command.error.CommandException;
+import org.spine3.server.command.error.UnsupportedCommandException;
+import org.spine3.server.type.CommandClass;
+
+import java.util.Set;
+
+/**
+ * The {@code CommandService} allows client applications to post commands and
+ * receive updates from the application backend.
+ *
+ * @author Alexander Yevsyukov
+ */
+public class CommandService
+        extends CommandServiceGrpc.CommandServiceImplBase {
+
+    private final ImmutableMap<CommandClass, BoundedContext> boundedContextMap;
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    protected CommandService(Builder builder) {
+        this.boundedContextMap = builder.getBoundedContextMap();
+    }
+
+    @SuppressWarnings("RefusedBequest") // as we override default implementation with `unimplemented` status.
+    @Override
+    public void post(Command request, StreamObserver<Response> responseObserver) {
+        final CommandClass commandClass = CommandClass.of(request);
+        final BoundedContext boundedContext = boundedContextMap.get(commandClass);
+        if (boundedContext == null) {
+            handleUnsupported(request, responseObserver);
+        } else {
+            boundedContext.getCommandBus()
+                          .post(request, responseObserver);
+        }
+    }
+
+    private static void handleUnsupported(Command request, StreamObserver<Response> responseObserver) {
+        final CommandException unsupported = new UnsupportedCommandException(request);
+        log().error("Unsupported command posted to CommandService", unsupported);
+        responseObserver.onError(Statuses.invalidArgumentWithCause(unsupported));
+    }
+
+    public static class Builder {
+
+        private final Set<BoundedContext> boundedContexts = Sets.newHashSet();
+        private ImmutableMap<CommandClass, BoundedContext> boundedContextMap;
+
+        public Builder addBoundedContext(BoundedContext boundedContext) {
+            // Save it to a temporary set so that it is easy to remove it if needed.
+            boundedContexts.add(boundedContext);
+            return this;
+        }
+
+        public Builder removeBoundedContext(BoundedContext boundedContext) {
+            boundedContexts.remove(boundedContext);
+            return this;
+        }
+
+        @SuppressWarnings("ReturnOfCollectionOrArrayField") // is immutable
+        public ImmutableMap<CommandClass, BoundedContext> getBoundedContextMap() {
+            return boundedContextMap;
+        }
+
+        /**
+         * Builds the {@link CommandService}.
+         */
+        public CommandService build() {
+            this.boundedContextMap = createBoundedContextMap();
+            final CommandService result = new CommandService(this);
+            return result;
+        }
+
+        private ImmutableMap<CommandClass, BoundedContext> createBoundedContextMap() {
+            final ImmutableMap.Builder<CommandClass, BoundedContext> builder = ImmutableMap.builder();
+            for (BoundedContext boundedContext : boundedContexts) {
+                addBoundedContext(builder, boundedContext);
+            }
+            return builder.build();
+        }
+
+        private static void addBoundedContext(ImmutableMap.Builder<CommandClass, BoundedContext> mapBuilder,
+                BoundedContext boundedContext) {
+            final Set<CommandClass> cmdClasses = boundedContext.getCommandBus()
+                                                               .getSupportedCommandClasses();
+            for (CommandClass commandClass : cmdClasses) {
+                mapBuilder.put(commandClass, boundedContext);
+            }
+        }
+    }
+
+    private enum LogSingleton {
+        INSTANCE;
+        @SuppressWarnings("NonSerializableFieldInSerializableClass")
+        private final Logger value = LoggerFactory.getLogger(CommandService.class);
+    }
+
+    private static Logger log() {
+        return LogSingleton.INSTANCE.value;
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/QueryService.java b/server/src/main/java/org/spine3/server/QueryService.java
new file mode 100644
index 00000000000..3111f110332
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/QueryService.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import io.grpc.stub.StreamObserver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spine3.base.Queries;
+import org.spine3.client.Query;
+import org.spine3.client.QueryResponse;
+import org.spine3.client.grpc.QueryServiceGrpc;
+import org.spine3.protobuf.TypeUrl;
+
+import java.util.Set;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * The {@code QueryService} provides a synchronous way to fetch read-side state from the server.
+ *
+ * <p> For asynchronous read-side updates please see {@link SubscriptionService}.
+ *
+ * @author Alex Tymchenko
+ */
+public class QueryService extends QueryServiceGrpc.QueryServiceImplBase {
+
+    private final ImmutableMap<TypeUrl, BoundedContext> typeToContextMap;
+
+    private QueryService(Builder builder) {
+        this.typeToContextMap = builder.getBoundedContextMap();
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    @SuppressWarnings("RefusedBequest") // as we override default implementation with `unimplemented` status.
+    @Override
+    public void read(Query query, StreamObserver<QueryResponse> responseObserver) {
+        log().debug("Incoming query: {}", query);
+
+        final TypeUrl type = Queries.typeOf(query);
+        checkNotNull(type, "Unknown type for query target");
+
+        final BoundedContext boundedContext = typeToContextMap.get(type);
+        try {
+            boundedContext.getStand()
+                          .execute(query, responseObserver);
+        } catch (@SuppressWarnings("OverlyBroadCatchBlock") Exception e) {
+            log().error("Error processing query", e);
+            responseObserver.onError(e);
+        }
+    }
+
+    public static class Builder {
+        private final Set<BoundedContext> boundedContexts = Sets.newHashSet();
+        private ImmutableMap<TypeUrl, BoundedContext> typeToContextMap;
+
+        public Builder addBoundedContext(BoundedContext boundedContext) {
+            // Save it to a temporary set so that it is easy to remove it if needed.
+            boundedContexts.add(boundedContext);
+            return this;
+        }
+
+        public Builder removeBoundedContext(BoundedContext boundedContext) {
+            boundedContexts.remove(boundedContext);
+            return this;
+        }
+
+        @SuppressWarnings("ReturnOfCollectionOrArrayField") // the collection returned is immutable
+        public ImmutableMap<TypeUrl, BoundedContext> getBoundedContextMap() {
+            return typeToContextMap;
+        }
+
+        /**
+         * Builds the {@link QueryService}.
+         *
+         * @throws IllegalStateException if no bounded contexts were added.
+         */
+        public QueryService build() throws IllegalStateException {
+            if (boundedContexts.isEmpty()) {
+                throw new IllegalStateException("Query service must have at least one bounded context.");
+            }
+            this.typeToContextMap = createBoundedContextMap();
+            final QueryService result = new QueryService(this);
+            return result;
+        }
+
+        private ImmutableMap<TypeUrl, BoundedContext> createBoundedContextMap() {
+            final ImmutableMap.Builder<TypeUrl, BoundedContext> builder = ImmutableMap.builder();
+            for (BoundedContext boundedContext : boundedContexts) {
+                addBoundedContext(builder, boundedContext);
+            }
+            return builder.build();
+        }
+
+        private static void addBoundedContext(ImmutableMap.Builder<TypeUrl, BoundedContext> mapBuilder,
+                                              BoundedContext boundedContext) {
+
+            final ImmutableSet<TypeUrl> exposedTypes = boundedContext.getStand()
+                                                                       .getExposedTypes();
+
+            for (TypeUrl availableType : exposedTypes) {
+                mapBuilder.put(availableType, boundedContext);
+            }
+        }
+    }
+
+    private static Logger log() {
+        return LogSingleton.INSTANCE.value;
+    }
+
+    private enum LogSingleton {
+        INSTANCE;
+        @SuppressWarnings("NonSerializableFieldInSerializableClass")
+        private final Logger value = LoggerFactory.getLogger(QueryService.class);
+    }
+
+}
diff --git a/server/src/main/java/org/spine3/server/SubscriptionService.java b/server/src/main/java/org/spine3/server/SubscriptionService.java
new file mode 100644
index 00000000000..b62c9f867e1
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/SubscriptionService.java
@@ -0,0 +1,212 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import com.google.protobuf.Any;
+import io.grpc.stub.StreamObserver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spine3.base.Response;
+import org.spine3.base.Responses;
+import org.spine3.client.Subscription;
+import org.spine3.client.SubscriptionUpdate;
+import org.spine3.client.Target;
+import org.spine3.client.Topic;
+import org.spine3.client.grpc.SubscriptionServiceGrpc;
+import org.spine3.protobuf.KnownTypes;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.stand.Stand;
+
+import java.util.Set;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * The {@code SubscriptionService} provides an asynchronous way to fetch read-side state from the server.
+ *
+ * <p> For synchronous read-side updates please see {@link QueryService}.
+ *
+ * @author Alex Tymchenko
+ */
+public class SubscriptionService extends SubscriptionServiceGrpc.SubscriptionServiceImplBase {
+    private final ImmutableMap<TypeUrl, BoundedContext> typeToContextMap;
+
+    private SubscriptionService(Builder builder) {
+        this.typeToContextMap = builder.getBoundedContextMap();
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    @SuppressWarnings("RefusedBequest")     // as we override default implementation with `unimplemented` status.
+    @Override
+    public void subscribe(Topic topic, StreamObserver<Subscription> responseObserver) {
+        log().debug("Creating the subscription to a topic: {}", topic);
+
+        try {
+            final Target target = topic.getTarget();
+            final BoundedContext boundedContext = selectBoundedContext(target);
+            final Stand stand = boundedContext.getStand();
+
+            final Subscription subscription = stand.subscribe(target);
+
+            responseObserver.onNext(subscription);
+            responseObserver.onCompleted();
+        } catch (@SuppressWarnings("OverlyBroadCatchBlock") Exception e) {
+            log().error("Error processing subscription request", e);
+            responseObserver.onError(e);
+        }
+    }
+
+    @SuppressWarnings("RefusedBequest")     // as we override default implementation with `unimplemented` status.
+    @Override
+    public void activate(final Subscription subscription, final StreamObserver<SubscriptionUpdate> responseObserver) {
+        log().debug("Activating the subscription: {}", subscription);
+
+        try {
+            final BoundedContext boundedContext = selectBoundedContext(subscription);
+
+            final Stand.EntityUpdateCallback updateCallback = new Stand.EntityUpdateCallback() {
+                @Override
+                public void onStateChanged(Any newEntityState) {
+                    checkNotNull(subscription);
+                    final SubscriptionUpdate update = SubscriptionUpdate.newBuilder()
+                                                                        .setSubscription(subscription)
+                                                                        .setResponse(Responses.ok())
+                                                                        .addUpdates(newEntityState)
+                                                                        .build();
+                    responseObserver.onNext(update);
+                }
+            };
+            final Stand targetStand = boundedContext.getStand();
+            targetStand.activate(subscription, updateCallback);
+        } catch (@SuppressWarnings("OverlyBroadCatchBlock") Exception e) {
+            log().error("Error activating the subscription", e);
+            responseObserver.onError(e);
+        }
+    }
+
+    @SuppressWarnings("RefusedBequest")     // as we override default implementation with `unimplemented` status.
+    @Override
+    public void cancel(Subscription subscription, StreamObserver<Response> responseObserver) {
+        log().debug("Incoming cancel request for the subscription topic: {}", subscription);
+
+        final BoundedContext boundedContext = selectBoundedContext(subscription);
+        try {
+            final Stand stand = boundedContext.getStand();
+            stand.cancel(subscription);
+            responseObserver.onNext(Responses.ok());
+            responseObserver.onCompleted();
+        } catch (@SuppressWarnings("OverlyBroadCatchBlock") Exception e) {
+            log().error("Error processing cancel subscription request", e);
+            responseObserver.onError(e);
+        }
+    }
+
+    private BoundedContext selectBoundedContext(Subscription subscription) {
+        final String typeAsString = subscription.getType();
+        final TypeUrl type = KnownTypes.getTypeUrl(typeAsString);
+        checkNotNull(type, "Unknown type of the subscription");
+        final BoundedContext result = typeToContextMap.get(type);
+        return result;
+    }
+
+    private BoundedContext selectBoundedContext(Target target) {
+        final String typeAsString = target.getType();
+        final TypeUrl type = KnownTypes.getTypeUrl(typeAsString);
+        checkNotNull(type, "Unknown type of the target");
+        final BoundedContext result = typeToContextMap.get(type);
+        return result;
+    }
+
+    public static class Builder {
+        private final Set<BoundedContext> boundedContexts = Sets.newHashSet();
+        private ImmutableMap<TypeUrl, BoundedContext> typeToContextMap;
+
+        public Builder addBoundedContext(BoundedContext boundedContext) {
+            // Save it to a temporary set so that it is easy to remove it if needed.
+            boundedContexts.add(boundedContext);
+            return this;
+        }
+
+        public Builder removeBoundedContext(BoundedContext boundedContext) {
+            boundedContexts.remove(boundedContext);
+            return this;
+        }
+
+        @SuppressWarnings("ReturnOfCollectionOrArrayField") // the collection returned is immutable
+        public ImmutableMap<TypeUrl, BoundedContext> getBoundedContextMap() {
+            return typeToContextMap;
+        }
+
+        @SuppressWarnings("ReturnOfCollectionOrArrayField") // the collection returned is immutable
+        public ImmutableList<BoundedContext> getBoundedContexts() {
+            return ImmutableList.copyOf(boundedContexts);
+        }
+
+        /**
+         * Builds the {@link SubscriptionService}.
+         *
+         * @throws IllegalStateException if no bounded contexts were added.
+         */
+        public SubscriptionService build() throws IllegalStateException {
+            if (boundedContexts.isEmpty()) {
+                throw new IllegalStateException("Subscription service must have at least one bounded context.");
+            }
+            this.typeToContextMap = createBoundedContextMap();
+            final SubscriptionService result = new SubscriptionService(this);
+            return result;
+        }
+
+        private ImmutableMap<TypeUrl, BoundedContext> createBoundedContextMap() {
+            final ImmutableMap.Builder<TypeUrl, BoundedContext> builder = ImmutableMap.builder();
+            for (BoundedContext boundedContext : boundedContexts) {
+                addBoundedContext(builder, boundedContext);
+            }
+            return builder.build();
+        }
+
+        private static void addBoundedContext(ImmutableMap.Builder<TypeUrl, BoundedContext> mapBuilder,
+                                              BoundedContext boundedContext) {
+
+            final Stand stand = boundedContext.getStand();
+            final ImmutableSet<TypeUrl> exposedTypes = stand.getExposedTypes();
+            for (TypeUrl availableType : exposedTypes) {
+                mapBuilder.put(availableType, boundedContext);
+            }
+        }
+    }
+
+    private static Logger log() {
+        return LogSingleton.INSTANCE.value;
+    }
+
+    private enum LogSingleton {
+        INSTANCE;
+        @SuppressWarnings("NonSerializableFieldInSerializableClass")
+        private final Logger value = LoggerFactory.getLogger(SubscriptionService.class);
+    }
+
+}
diff --git a/server/src/main/java/org/spine3/server/aggregate/Aggregate.java b/server/src/main/java/org/spine3/server/aggregate/Aggregate.java
index 0026b573643..9f7714afc81 100644
--- a/server/src/main/java/org/spine3/server/aggregate/Aggregate.java
+++ b/server/src/main/java/org/spine3/server/aggregate/Aggregate.java
@@ -52,7 +52,7 @@
 import static org.spine3.protobuf.Timestamps.getCurrentTime;
 import static org.spine3.server.reflect.Classes.getHandledMessageClasses;
 import static org.spine3.util.Exceptions.wrappedCause;
-import static org.spine3.validate.Validate.checkIsPositive;
+import static org.spine3.validate.Validate.checkPositive;
 
 /**
  * Abstract base for aggregates.
@@ -430,7 +430,7 @@ private void applyEventOrSnapshot(Message eventOrSnapshot) throws InvocationTarg
      */
     @CheckReturnValue
     protected EventContext createEventContext(Message event, CommandContext commandContext, Timestamp whenModified) {
-        checkIsPositive(whenModified, "Aggregate modification time");
+        checkPositive(whenModified, "Aggregate modification time");
         final EventId eventId = generateId();
         final EventContext.Builder builder = EventContext.newBuilder()
                 .setEventId(eventId)
diff --git a/server/src/main/java/org/spine3/server/aggregate/AggregateRepository.java b/server/src/main/java/org/spine3/server/aggregate/AggregateRepository.java
index bec8e076324..7b231f27460 100644
--- a/server/src/main/java/org/spine3/server/aggregate/AggregateRepository.java
+++ b/server/src/main/java/org/spine3/server/aggregate/AggregateRepository.java
@@ -19,6 +19,7 @@
  */
 package org.spine3.server.aggregate;
 
+import com.google.protobuf.Any;
 import com.google.protobuf.Message;
 import org.spine3.base.Command;
 import org.spine3.base.CommandContext;
@@ -26,12 +27,14 @@
 import org.spine3.base.Errors;
 import org.spine3.base.Event;
 import org.spine3.base.FailureThrowable;
+import org.spine3.protobuf.AnyPacker;
 import org.spine3.server.BoundedContext;
 import org.spine3.server.command.CommandDispatcher;
 import org.spine3.server.command.CommandStatusService;
 import org.spine3.server.entity.GetTargetIdFromCommand;
 import org.spine3.server.entity.Repository;
 import org.spine3.server.event.EventBus;
+import org.spine3.server.stand.StandFunnel;
 import org.spine3.server.storage.AggregateEvents;
 import org.spine3.server.storage.AggregateStorage;
 import org.spine3.server.storage.Storage;
@@ -81,6 +84,7 @@ public abstract class AggregateRepository<I, A extends Aggregate<I, ?, ?>>
     private final GetTargetIdFromCommand<I, Message> getIdFunction = GetTargetIdFromCommand.newInstance();
     private final CommandStatusService commandStatusService;
     private final EventBus eventBus;
+    private final StandFunnel standFunnel;
 
     /**
      * Creates a new repository instance.
@@ -91,6 +95,7 @@ public AggregateRepository(BoundedContext boundedContext) {
         super(boundedContext);
         this.commandStatusService = boundedContext.getCommandBus().getCommandStatusService();
         this.eventBus = boundedContext.getEventBus();
+        this.standFunnel = boundedContext.getStandFunnel();
     }
 
     @Override
@@ -228,6 +233,9 @@ public void dispatch(Command request) throws IllegalStateException {
         //noinspection OverlyBroadCatchBlock
         try {
             store(aggregate);
+            final Message state = aggregate.getState();
+            final Any packedAny = AnyPacker.pack(state);
+            standFunnel.post(aggregateId, packedAny);
         } catch (Exception e) {
             commandStatusService.setToError(commandId, e);
         }
diff --git a/server/src/main/java/org/spine3/server/command/CommandValidator.java b/server/src/main/java/org/spine3/server/command/CommandValidator.java
index 3bd51bbf4ad..7d04a035ce7 100644
--- a/server/src/main/java/org/spine3/server/command/CommandValidator.java
+++ b/server/src/main/java/org/spine3/server/command/CommandValidator.java
@@ -35,7 +35,7 @@
 import static com.google.common.base.Preconditions.checkArgument;
 import static org.spine3.base.Identifiers.EMPTY_ID;
 import static org.spine3.base.Identifiers.idToString;
-import static org.spine3.validate.Validate.checkIsPositive;
+import static org.spine3.validate.Validate.checkPositive;
 import static org.spine3.validate.Validate.checkValid;
 import static org.spine3.validate.Validate.isDefault;
 
@@ -121,7 +121,7 @@ public static void checkCommand(Command command) {
         checkArgument(command.hasContext(), "Command context must be set.");
         final CommandContext context = command.getContext();
         checkValid(context.getCommandId());
-        checkIsPositive(context.getTimestamp(), "Command time");
+        checkPositive(context.getTimestamp(), "Command time");
         final Message commandMessage = Commands.getMessage(command);
         final Optional targetId = GetTargetIdFromCommand.asOptional(commandMessage);
         if (targetId.isPresent()) { // else - consider the command is not for an entity
diff --git a/server/src/main/java/org/spine3/server/command/ExecutorCommandScheduler.java b/server/src/main/java/org/spine3/server/command/ExecutorCommandScheduler.java
index 1ac7c732b93..e7e8bcf7feb 100644
--- a/server/src/main/java/org/spine3/server/command/ExecutorCommandScheduler.java
+++ b/server/src/main/java/org/spine3/server/command/ExecutorCommandScheduler.java
@@ -20,12 +20,13 @@
 
 package org.spine3.server.command;
 
+import com.google.protobuf.Duration;
 import org.spine3.base.Command;
 
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 
-import static java.util.concurrent.TimeUnit.SECONDS;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static org.spine3.base.CommandContext.Schedule;
 
 /**
@@ -40,24 +41,37 @@
 public class ExecutorCommandScheduler extends CommandScheduler {
 
     private static final int MIN_THREAD_POOL_SIZE = 5;
+    private static final int NANOS_IN_MILLISECOND = 1_000_000;
+    private static final int MILLIS_IN_SECOND = 1_000;
 
     private final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(MIN_THREAD_POOL_SIZE);
 
     @Override
     protected void doSchedule(final Command command) {
-        final long delaySec = getDelaySeconds(command);
+        final long delaySec = getDelayMilliseconds(command);
         executorService.schedule(new Runnable() {
             @Override
             public void run() {
                 post(command);
             }
-        }, delaySec, SECONDS);
+        }, delaySec, MILLISECONDS);
     }
 
-    private static long getDelaySeconds(Command command) {
+    private static long getDelayMilliseconds(Command command) {
         final Schedule schedule = command.getContext().getSchedule();
-        final long delaySec = schedule.getDelay().getSeconds();
-        return delaySec;
+        final Duration delay = schedule.getDelay();
+        final long delaySec = delay.getSeconds();
+        final long delayMillisFraction = delay.getNanos() / NANOS_IN_MILLISECOND;
+
+        /**
+         * Maximum value of {@link Duration#getSeconds()} is
+         * <a href="https://github.com/google/protobuf/blob/master/src/google/protobuf/duration.proto"+315,576,000,000.</a>.
+         *
+         * {@link Long.MAX_VALUE} is +9,223,372,036,854,775,807. That's why it is safe to multiply
+         * {@code delaySec * MILLIS_IN_SECOND}.
+         */
+        final long absoluteMillis = delaySec * MILLIS_IN_SECOND + delayMillisFraction;
+        return absoluteMillis;
     }
 
     @Override
diff --git a/server/src/main/java/org/spine3/server/entity/Entity.java b/server/src/main/java/org/spine3/server/entity/Entity.java
index eb5997f87d5..e4f86da0029 100644
--- a/server/src/main/java/org/spine3/server/entity/Entity.java
+++ b/server/src/main/java/org/spine3/server/entity/Entity.java
@@ -75,7 +75,7 @@ public abstract class Entity<I, S extends Message> {
     private static final int ID_CLASS_GENERIC_INDEX = 0;
 
     /** The index of the declaration of the generic parameter type {@code S} in this class. */
-    private static final int STATE_CLASS_GENERIC_INDEX = 1;
+    protected static final int STATE_CLASS_GENERIC_INDEX = 1;
 
     /** Supported ID types except {@link Message}s. */
     private static final ImmutableSet<Class<?>> SUPPORTED_SIMPLE_ID_TYPES = ImmutableSet.<Class<?>>builder()
@@ -143,9 +143,9 @@ private S createDefaultState() {
      */
     @CheckReturnValue
     public S getState() {
-        final S result = state == null ?
-                         getDefaultState() :
-                         state;
+        final S result = state == null
+                         ? getDefaultState()
+                         : state;
         return result;
     }
 
@@ -246,9 +246,9 @@ public I getId() {
     @CheckReturnValue
     @Nonnull
     public Timestamp whenModified() {
-        final Timestamp result = whenModified == null ?
-                                 Timestamp.getDefaultInstance() :
-                                 whenModified;
+        final Timestamp result = whenModified == null
+                                 ? Timestamp.getDefaultInstance()
+                                 : whenModified;
         return result;
     }
 
diff --git a/server/src/main/java/org/spine3/server/entity/EntityRepository.java b/server/src/main/java/org/spine3/server/entity/EntityRepository.java
index bdda363c0c4..cb888dc0ecf 100644
--- a/server/src/main/java/org/spine3/server/entity/EntityRepository.java
+++ b/server/src/main/java/org/spine3/server/entity/EntityRepository.java
@@ -20,20 +20,38 @@
 
 package org.spine3.server.entity;
 
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
 import com.google.protobuf.Any;
+import com.google.protobuf.FieldMask;
 import com.google.protobuf.Message;
 import com.google.protobuf.Timestamp;
+import org.spine3.client.EntityFilters;
+import org.spine3.client.EntityId;
 import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.TypeUrl;
 import org.spine3.server.BoundedContext;
-import org.spine3.server.storage.EntityStorage;
 import org.spine3.server.storage.EntityStorageRecord;
+import org.spine3.server.storage.RecordStorage;
 import org.spine3.server.storage.Storage;
 import org.spine3.server.storage.StorageFactory;
 
+import javax.annotation.CheckReturnValue;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
 
+import static com.google.common.base.Preconditions.checkState;
 import static org.spine3.protobuf.AnyPacker.unpack;
+import static org.spine3.protobuf.Messages.toMessageClass;
 import static org.spine3.validate.Validate.isDefault;
 
 /**
@@ -53,7 +71,7 @@ public EntityRepository(BoundedContext boundedContext) {
     /** {@inheritDoc} */
     @Override
     protected Storage createStorage(StorageFactory factory) {
-        final Storage result = factory.createEntityStorage(getEntityClass());
+        final Storage result = factory.createRecordStorage(getEntityClass());
         return result;
     }
 
@@ -64,16 +82,16 @@ protected Storage createStorage(StorageFactory factory) {
      * @throws IllegalStateException if the storage is null
      */
     @Nonnull
-    protected EntityStorage<I> entityStorage() {
+    protected RecordStorage<I> recordStorage() {
         @SuppressWarnings("unchecked") // It is safe to cast as we control the creation in createStorage().
-        final EntityStorage<I> storage = (EntityStorage<I>) getStorage();
+        final RecordStorage<I> storage = (RecordStorage<I>) getStorage();
         return checkStorage(storage);
     }
 
     /** {@inheritDoc} */
     @Override
     public void store(E entity) {
-        final EntityStorage<I> storage = entityStorage();
+        final RecordStorage<I> storage = recordStorage();
         final EntityStorageRecord record = toEntityRecord(entity);
         storage.write(entity.getId(), record);
     }
@@ -82,7 +100,7 @@ public void store(E entity) {
     @Nullable
     @Override
     public E load(I id) {
-        final EntityStorage<I> storage = entityStorage();
+        final RecordStorage<I> storage = recordStorage();
         final EntityStorageRecord record = storage.read(id);
         if (isDefault(record)) {
             return null;
@@ -91,9 +109,147 @@ public E load(I id) {
         return entity;
     }
 
+    /**
+     * Loads all the entities in this repository with IDs, contained within the passed {@code ids} values.
+     *
+     * <p>Provides a convenience wrapper around multiple invocations of {@link #load(Object)}. Descendants may
+     * optimize the execution of this method, choosing the most suitable way for the particular storage engine used.
+     *
+     * <p>The result only contains those entities which IDs are contained inside the passed {@code ids}.
+     * The resulting collection is always returned with no {@code null} values.
+     *
+     * <p>The order of objects in the result is not guaranteed to be the same as the order of IDs passed as argument.
+     *
+     * <p>In case IDs contain duplicates, the result may also contain duplicates, depending on particular
+     * implementation.
+     *
+     * <p>NOTE: The storage must be assigned before calling this method.
+     *
+     * @param ids entity IDs to search for
+     * @return all the entities in this repository with the IDs matching the given {@code Iterable}
+     */
+    @CheckReturnValue
+    public ImmutableCollection<E> loadAll(Iterable<I> ids) {
+        return loadAll(ids, FieldMask.getDefaultInstance());
+    }
+
+    /**
+     * Loads all the entities in this repository by their IDs and applies the {@link FieldMask} to each of them.
+     *
+     * <p>Acts in the same way as {@link #loadAll(Iterable)}, with the {@code FieldMask} applied to the results.
+     *
+     * <p>Field mask is applied according to
+     * <a href="https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.FieldMask>FieldMask specs</a>.
+     *
+     * <p>NOTE: The storage must be assigned before calling this method.
+     *
+     * @param ids       entity IDs to search for
+     * @param fieldMask mask to apply on entities
+     * @return all the entities in this repository with the IDs contained in the given {@code ids}
+     * @see #loadAll(Iterable)
+     */
+    @CheckReturnValue
+    public ImmutableCollection<E> loadAll(Iterable<I> ids, FieldMask fieldMask) {
+        final RecordStorage<I> storage = recordStorage();
+        final Iterable<EntityStorageRecord> entityStorageRecords = storage.readMultiple(ids);
+
+        final Iterator<I> idIterator = ids.iterator();
+        final Iterator<EntityStorageRecord> recordIterator = entityStorageRecords.iterator();
+        final List<E> entities = new LinkedList<>();
+
+        while (idIterator.hasNext() && recordIterator.hasNext()) {
+            final I id = idIterator.next();
+            final EntityStorageRecord record = recordIterator.next();
+
+            if (record == null) { /*    Record is nullable here since {@code RecordStorage#findBulk}    *
+                                   *    returns an {@code Iterable} that may contain nulls.             */
+                continue;
+            }
+
+            final E entity = toEntity(id, record, fieldMask);
+            entities.add(entity);
+        }
+
+        return ImmutableList.copyOf(entities);
+    }
+
+    /**
+     * Loads all the entities in this repository.
+     *
+     * <p>NOTE: The storage must be assigned before calling this method.
+     *
+     * @return all the entities in this repository
+     * @see #loadAll(Iterable)
+     */
+    @CheckReturnValue
+    public ImmutableCollection<E> loadAll() {
+        final RecordStorage<I> storage = recordStorage();
+        final Map<I, EntityStorageRecord> recordMap = storage.readAll();
+
+        final ImmutableCollection<E> entities =
+                FluentIterable.from(recordMap.entrySet())
+                              .transform(storageRecordToEntityTransformer())
+                              .toList();
+        return entities;
+    }
+
+    /**
+     * Finds all the entities passing the given filters and applies the given {@link FieldMask} to the results.
+     *
+     * <p>Field mask is applied according to
+     * <a href="https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.FieldMask>FieldMask specs</a>.
+     *
+     * <p>At this point only {@link org.spine3.client.EntityIdFilter} is supported. All other filters are ignored.
+     *
+     * <p>Filtering by IDs set via {@code EntityIdFilter} is performed in the same way as by {@link #loadAll(Iterable)}.
+     *
+     * <p>NOTE: The storage must be assigned before calling this method.
+     *
+     * @param filters   entity filters
+     * @param fieldMask mask to apply to the entities
+     * @return all the entities in this repository passed the filters.
+     */
+    @CheckReturnValue
+    public ImmutableCollection<E> find(EntityFilters filters, FieldMask fieldMask) {
+        final List<EntityId> idsList = filters.getIdFilter()
+                                              .getIdsList();
+        final Class<I> expectedIdClass = getIdClass();
+
+        final Collection<I> domainIds = Collections2.transform(idsList, new Function<EntityId, I>() {
+            @Nullable
+            @Override
+            public I apply(@Nullable EntityId input) {
+                Preconditions.checkNotNull(input);
+                final Any idAsAny = input.getId();
+
+                final TypeUrl typeUrl = TypeUrl.ofEnclosed(idAsAny);
+                final Class messageClass = toMessageClass(typeUrl);
+
+                final boolean classIsSame = expectedIdClass.equals(messageClass);
+                checkState(classIsSame,
+                           "Unexpected ID of type " + messageClass + " encountered. " + "Expected: " + expectedIdClass);
+
+                final Message idAsMessage = AnyPacker.unpack(idAsAny);
+
+                // As the message class is the same as expected, the conversion is safe.
+                @SuppressWarnings("unchecked")
+                final I id = (I) idAsMessage;
+                return id;
+            }
+        });
+
+        final ImmutableCollection<E> result = loadAll(domainIds, fieldMask);
+        return result;
+    }
+
     private E toEntity(I id, EntityStorageRecord record) {
+        return toEntity(id, record, FieldMask.getDefaultInstance());
+    }
+
+    private E toEntity(I id, EntityStorageRecord record, FieldMask fieldMask) {
         final E entity = create(id);
-        final M state = unpack(record.getState());
+        @SuppressWarnings("unchecked")
+        final M state = (M) FieldMasks.applyMask(fieldMask, unpack(record.getState()), getEntityStateType());
         entity.setState(state, record.getVersion(), record.getWhenModified());
         return entity;
     }
@@ -104,9 +260,21 @@ private EntityStorageRecord toEntityRecord(E entity) {
         final Timestamp whenModified = entity.whenModified();
         final int version = entity.getVersion();
         final EntityStorageRecord.Builder builder = EntityStorageRecord.newBuilder()
-                .setState(stateAny)
-                .setWhenModified(whenModified)
-                .setVersion(version);
+                                                                       .setState(stateAny)
+                                                                       .setWhenModified(whenModified)
+                                                                       .setVersion(version);
         return builder.build();
     }
+
+    private Function<Map.Entry<I, EntityStorageRecord>, E> storageRecordToEntityTransformer() {
+        return new Function<Map.Entry<I, EntityStorageRecord>, E>() {
+            @Nullable
+            @Override
+            public E apply(@Nullable Map.Entry<I, EntityStorageRecord> input) {
+                Preconditions.checkNotNull(input);
+                final E result = toEntity(input.getKey(), input.getValue());
+                return result;
+            }
+        };
+    }
 }
diff --git a/server/src/main/java/org/spine3/server/entity/FieldMasks.java b/server/src/main/java/org/spine3/server/entity/FieldMasks.java
new file mode 100644
index 00000000000..3a1a8076d2a
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/entity/FieldMasks.java
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.entity;
+
+import com.google.protobuf.Descriptors;
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.Message;
+import com.google.protobuf.ProtocolStringList;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spine3.protobuf.KnownTypes;
+import org.spine3.protobuf.TypeUrl;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * A utility class for {@code FieldMask} processing against instances of {@link Message}.
+ *
+ * @author Dmytro Dashenkov
+ */
+@SuppressWarnings("UtilityClass")
+public class FieldMasks {
+
+    private static final String CONSTRUCTOR_INVOCATION_ERROR_LOGGING_PATTERN =
+            "Constructor for type %s could not be found or called: ";
+    private static final String BUILDER_CLASS_ERROR_LOGGING_PATTERN =
+            "Class for name %s could not be found. Try to rebuild the project. Make sure \"known_types.properties\" exists.";
+    private static final String TYPE_CAST_ERROR_LOGGING_PATTERN =
+            "Class %s must be assignable from com.google.protobuf.Message. Try to rebuild the project. Make sure type URL is valid.";
+
+    private FieldMasks() {
+    }
+
+    /**
+     * Applies the given {@code FieldMask} to given collection of {@link Message}s.
+     * Does not change the {@link Collection} itself.
+     *
+     * <p>In case the {@code FieldMask} instance contains invalid field declarations, they are ignored and
+     * do not affect the execution result.
+     *
+     * @param mask     {@code FieldMask} to apply to each item of the input {@link Collection}.
+     * @param messages {@link Message}s to filter.
+     * @param type     type of the {@link Message}s.
+     * @return messages with the {@code FieldMask} applied
+     */
+    @Nonnull
+    public static <M extends Message, B extends Message.Builder> Collection<M> applyMask(FieldMask mask,
+                                                                                         Collection<M> messages,
+                                                                                         TypeUrl type) {
+        final List<M> filtered = new LinkedList<>();
+        final ProtocolStringList filter = mask.getPathsList();
+        final Class<B> builderClass = getBuilderForType(type);
+
+        if (filter.isEmpty() || builderClass == null) {
+            return Collections.unmodifiableCollection(messages);
+        }
+
+        try {
+            final Constructor<B> builderConstructor = builderClass.getDeclaredConstructor();
+            builderConstructor.setAccessible(true);
+
+            for (Message wholeMessage : messages) {
+                final M message = messageForFilter(filter, builderConstructor, wholeMessage);
+                filtered.add(message);
+            }
+        } catch (NoSuchMethodException |
+                InvocationTargetException |
+                IllegalAccessException |
+                InstantiationException e) {
+            // If any reflection failure happens, return all the data without any mask applied.
+            log().warn(String.format(CONSTRUCTOR_INVOCATION_ERROR_LOGGING_PATTERN, builderClass.getCanonicalName()), e);
+            return Collections.unmodifiableCollection(messages);
+        }
+        return Collections.unmodifiableList(filtered);
+    }
+
+    /**
+     * Applies the {@code FieldMask} to the given {@link Message} the {@code mask} parameter is valid.
+     *
+     * <p>In case the {@code FieldMask} instance contains invalid field declarations, they are ignored and
+     * do not affect the execution result.
+     *
+     * @param mask    the {@code FieldMask} to apply.
+     * @param message the {@link Message} to apply given mask to.
+     * @param typeUrl type of given {@link Message}.
+     * @return the message of the same type as the given one with only selected fields if the {@code mask} is valid,
+     * original message otherwise.
+     */
+    public static <M extends Message> M applyMask(FieldMask mask, M message, TypeUrl typeUrl) {
+        if (!mask.getPathsList()
+                 .isEmpty()) {
+            return doApply(mask, message, typeUrl);
+        }
+        return message;
+    }
+
+    private static <M extends Message, B extends Message.Builder> M doApply(FieldMask mask, M message, TypeUrl type) {
+        final ProtocolStringList filter = mask.getPathsList();
+        final Class<B> builderClass = getBuilderForType(type);
+
+        if (builderClass == null) {
+            return message;
+        }
+
+        try {
+            final Constructor<B> builderConstructor = builderClass.getDeclaredConstructor();
+            builderConstructor.setAccessible(true);
+
+            final M result = messageForFilter(filter, builderConstructor, message);
+            return result;
+        } catch (NoSuchMethodException |
+                InvocationTargetException |
+                IllegalAccessException |
+                InstantiationException e) {
+            log().warn(String.format(CONSTRUCTOR_INVOCATION_ERROR_LOGGING_PATTERN, builderClass.getCanonicalName()), e);
+            return message;
+        }
+    }
+
+    private static <M extends Message, B extends Message.Builder> M messageForFilter(
+            ProtocolStringList filter,
+            Constructor<B> builderConstructor, Message wholeMessage)
+            throws InstantiationException,
+            IllegalAccessException,
+            InvocationTargetException {
+        final B builder = builderConstructor.newInstance();
+
+        final List<Descriptors.FieldDescriptor> fields = wholeMessage.getDescriptorForType()
+                                                                     .getFields();
+        for (Descriptors.FieldDescriptor field : fields) {
+            if (filter.contains(field.getFullName())) {
+                builder.setField(field, wholeMessage.getField(field));
+            }
+        }
+        @SuppressWarnings("unchecked")       // It's fine as the constructor is of {@code MessageCls.Builder} type.
+        final M result = (M) builder.build();
+        return result;
+    }
+
+    @SuppressWarnings("unchecked")      // We assume that {@code KnownTypes#getClassName(TypeUrl) works properly.
+    @Nullable
+    private static <B extends Message.Builder> Class<B> getBuilderForType(TypeUrl typeUrl) {
+        Class<B> builderClass;
+        final String className = KnownTypes.getClassName(typeUrl)
+                                           .value();
+        try {
+            builderClass = (Class<B>) Class.forName(className)
+                                           .getClasses()[0];
+        } catch (ClassNotFoundException e) {
+            final String message = String.format(
+                    BUILDER_CLASS_ERROR_LOGGING_PATTERN,
+                    className);
+            log().warn(message, e);
+            builderClass = null;
+        } catch (ClassCastException e) {
+            final String message = String.format(
+                    TYPE_CAST_ERROR_LOGGING_PATTERN,
+                    className);
+            log().warn(message, e);
+            builderClass = null;
+        }
+
+        return builderClass;
+    }
+
+    private static Logger log() {
+        return LogSingleton.INSTANCE.value;
+    }
+
+    private enum LogSingleton {
+        INSTANCE;
+        @SuppressWarnings("NonSerializableFieldInSerializableClass")
+        private final Logger value = LoggerFactory.getLogger(FieldMasks.class);
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/entity/Repository.java b/server/src/main/java/org/spine3/server/entity/Repository.java
index 913930640cf..3047966918e 100644
--- a/server/src/main/java/org/spine3/server/entity/Repository.java
+++ b/server/src/main/java/org/spine3/server/entity/Repository.java
@@ -20,16 +20,20 @@
 
 package org.spine3.server.entity;
 
+import org.spine3.protobuf.KnownTypes;
+import org.spine3.protobuf.TypeUrl;
 import org.spine3.server.BoundedContext;
 import org.spine3.server.reflect.Classes;
 import org.spine3.server.storage.Storage;
 import org.spine3.server.storage.StorageFactory;
+import org.spine3.type.ClassName;
 
 import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 
+import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.base.Throwables.propagate;
 import static java.lang.reflect.Modifier.isPrivate;
@@ -40,7 +44,6 @@
  *
  * @param <I> the type of IDs of entities managed by the repository
  * @param <E> the entity type
- *
  * @author Alexander Yevsyukov
  */
 public abstract class Repository<I, E extends Entity<I, ?>> implements AutoCloseable {
@@ -62,6 +65,20 @@ public abstract class Repository<I, E extends Entity<I, ?>> implements AutoClose
     /** The data storage for this repository. */
     private Storage storage;
 
+    /**
+     * Cached value for the entity state type.
+     *
+     * <p>Used to optimise heavy {@link #getEntityStateType()} calls.
+     **/
+    private volatile TypeUrl entityStateType;
+
+    /**
+     * Cached value for the entity class.
+     *
+     * <p>Used to optimize heavy {@link #getEntityClass()} calls.
+     **/
+    private volatile Class<E> entityClass;
+
     /**
      * Creates the repository in the passed {@link BoundedContext}.
      *
@@ -112,7 +129,24 @@ protected Class<I> getIdClass() {
     /** Returns the class of entities managed by this repository. */
     @CheckReturnValue
     protected Class<E> getEntityClass() {
-        return Classes.getGenericParameterType(getClass(), ENTITY_CLASS_GENERIC_INDEX);
+        if (entityClass == null) {
+            entityClass = Classes.getGenericParameterType(getClass(), ENTITY_CLASS_GENERIC_INDEX);
+        }
+        checkNotNull(entityClass);
+        return entityClass;
+    }
+
+    /** Returns the {@link TypeUrl} for the state objects wrapped by entities managed by this repository */
+    @CheckReturnValue
+    public TypeUrl getEntityStateType() {
+        if (entityStateType == null) {
+            final Class<E> entityClass = getEntityClass();
+            final Class<Object> stateClass = Classes.getGenericParameterType(entityClass, Entity.STATE_CLASS_GENERIC_INDEX);
+            final ClassName stateClassName = ClassName.of(stateClass);
+            entityStateType = KnownTypes.getTypeUrl(stateClassName);
+        }
+        checkNotNull(entityStateType);
+        return entityStateType;
     }
 
     /**
@@ -135,7 +169,7 @@ public E create(I id) {
     /**
      * Stores the passed object.
      *
-     * <p>The storage must be assigned before calling this method.
+     * <p>NOTE: The storage must be assigned before calling this method.
      *
      * @param obj an instance to store
      */
@@ -144,7 +178,7 @@ public E create(I id) {
     /**
      * Loads the entity with the passed ID.
      *
-     * <p>The storage must be assigned before calling this method.
+     * <p>NOTE: The storage must be assigned before calling this method.
      *
      * @param id the id of the entity to load
      * @return the entity or {@code null} if there's no entity with such id
diff --git a/server/src/main/java/org/spine3/server/event/enrich/EventEnricher.java b/server/src/main/java/org/spine3/server/event/enrich/EventEnricher.java
index 1cb7908eee4..2eae622e809 100644
--- a/server/src/main/java/org/spine3/server/event/enrich/EventEnricher.java
+++ b/server/src/main/java/org/spine3/server/event/enrich/EventEnricher.java
@@ -268,7 +268,7 @@ private void checkDuplicate(EnrichmentFunction<?, ?> function) {
          * @see EnrichmentFunction
          */
         @VisibleForTesting
-        /* package */  static class SameTransition implements Predicate<EnrichmentFunction> {
+        /* package */ static class SameTransition implements Predicate<EnrichmentFunction> {
 
             private final EnrichmentFunction function;
 
diff --git a/server/src/main/java/org/spine3/server/event/enrich/EventMessageEnricher.java b/server/src/main/java/org/spine3/server/event/enrich/EventMessageEnricher.java
index d80930e41e1..451eae0a3be 100644
--- a/server/src/main/java/org/spine3/server/event/enrich/EventMessageEnricher.java
+++ b/server/src/main/java/org/spine3/server/event/enrich/EventMessageEnricher.java
@@ -127,9 +127,9 @@ private void setFields(Message.Builder builder, S eventMsg) {
 
     private Object getSrcFieldValue(FieldDescriptor srcField, S eventMsg) {
         final boolean isContextField = srcField.getContainingType().equals(EventContext.getDescriptor());
-        final Object result = isContextField ?
-                getContext().getField(srcField) :
-                eventMsg.getField(srcField);
+        final Object result = isContextField
+                              ? getContext().getField(srcField)
+                              : eventMsg.getField(srcField);
         return result;
     }
 }
diff --git a/server/src/main/java/org/spine3/server/event/enrich/ReferenceValidator.java b/server/src/main/java/org/spine3/server/event/enrich/ReferenceValidator.java
index 79d88f044d5..eb25531a569 100644
--- a/server/src/main/java/org/spine3/server/event/enrich/ReferenceValidator.java
+++ b/server/src/main/java/org/spine3/server/event/enrich/ReferenceValidator.java
@@ -113,9 +113,9 @@ private static FieldDescriptor findField(String fieldNameFull, Descriptor srcMes
      * if the field name contains {@link ReferenceValidator#CONTEXT_REFERENCE}.
      */
     private Descriptor getSrcMessage(String fieldName) {
-        final Descriptor msg = fieldName.contains(CONTEXT_REFERENCE) ?
-                EventContext.getDescriptor() :
-                eventDescriptor;
+        final Descriptor msg = fieldName.contains(CONTEXT_REFERENCE)
+                               ? EventContext.getDescriptor()
+                               : eventDescriptor;
         return msg;
     }
 
diff --git a/server/src/main/java/org/spine3/server/projection/ProjectionRepository.java b/server/src/main/java/org/spine3/server/projection/ProjectionRepository.java
index 5bfb59651ef..08bfb88faa3 100644
--- a/server/src/main/java/org/spine3/server/projection/ProjectionRepository.java
+++ b/server/src/main/java/org/spine3/server/projection/ProjectionRepository.java
@@ -21,21 +21,25 @@
 package org.spine3.server.projection;
 
 import com.google.common.collect.ImmutableSet;
+import com.google.protobuf.Any;
 import com.google.protobuf.Message;
 import com.google.protobuf.Timestamp;
 import io.grpc.stub.StreamObserver;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.spine3.Internal;
 import org.spine3.base.Event;
 import org.spine3.base.EventContext;
 import org.spine3.base.Events;
+import org.spine3.protobuf.AnyPacker;
 import org.spine3.server.BoundedContext;
 import org.spine3.server.entity.EntityRepository;
 import org.spine3.server.event.EventDispatcher;
 import org.spine3.server.event.EventFilter;
 import org.spine3.server.event.EventStore;
 import org.spine3.server.event.EventStreamQuery;
-import org.spine3.server.storage.EntityStorage;
+import org.spine3.server.stand.StandFunnel;
+import org.spine3.server.storage.RecordStorage;
 import org.spine3.server.storage.ProjectionStorage;
 import org.spine3.server.storage.Storage;
 import org.spine3.server.storage.StorageFactory;
@@ -82,10 +86,14 @@ protected enum Status {
     private Status status = Status.CREATED;
 
     /** An underlying entity storage used to store projections. */
-    private EntityStorage<I> entityStorage;
+    private RecordStorage<I> recordStorage;
+
+    /** An instance of {@link StandFunnel} to be informed about state updates */
+    private final StandFunnel standFunnel;
 
     protected ProjectionRepository(BoundedContext boundedContext) {
         super(boundedContext);
+        this.standFunnel = boundedContext.getStandFunnel();
     }
 
     protected Status getStatus() {
@@ -106,7 +114,7 @@ protected boolean isOnline() {
     protected Storage createStorage(StorageFactory factory) {
         final Class<P> projectionClass = getEntityClass();
         final ProjectionStorage<I> projectionStorage = factory.createProjectionStorage(projectionClass);
-        this.entityStorage = projectionStorage.getEntityStorage();
+        this.recordStorage = projectionStorage.getRecordStorage();
         return projectionStorage;
     }
 
@@ -133,8 +141,8 @@ public void close() throws Exception {
     @Override
     @Nonnull
     @SuppressWarnings("RefusedBequest")
-    protected EntityStorage<I> entityStorage() {
-        return checkStorage(entityStorage);
+    protected RecordStorage<I> recordStorage() {
+        return checkStorage(recordStorage);
     }
 
     /**
@@ -223,8 +231,11 @@ public void dispatch(Event event) {
     /**
      * Dispatches event to a projection without checking the status of the repository.
      *
+     * <p>Also posts an update to the {@code StandFunnel} instance for this repository.
+     *
      * @param event the event to dispatch
      */
+    @Internal
     /* package */ void internalDispatch(Event event) {
         final Message eventMessage = Events.getMessage(event);
         final EventContext context = event.getContext();
@@ -232,6 +243,9 @@ public void dispatch(Event event) {
         final P projection = load(id);
         projection.handle(eventMessage, context);
         store(projection);
+        final M state = projection.getState();
+        final Any packedState = AnyPacker.pack(state);
+        standFunnel.post(id, packedState);
         final ProjectionStorage<I> storage = projectionStorage();
         final Timestamp eventTime = context.getTimestamp();
         storage.writeLastHandledEventTime(eventTime);
diff --git a/server/src/main/java/org/spine3/server/stand/AggregateQueryProcessor.java b/server/src/main/java/org/spine3/server/stand/AggregateQueryProcessor.java
new file mode 100644
index 00000000000..f2dc30c692c
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/AggregateQueryProcessor.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.base.Function;
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.Any;
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.Message;
+import org.spine3.client.EntityFilters;
+import org.spine3.client.EntityId;
+import org.spine3.client.EntityIdFilter;
+import org.spine3.client.Query;
+import org.spine3.client.Target;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.storage.EntityStorageRecord;
+import org.spine3.server.storage.StandStorage;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Processes the queries targeting {@link org.spine3.server.aggregate.Aggregate} state.
+ *
+ * @author Alex Tymchenko
+ */
+/* package */ class AggregateQueryProcessor implements QueryProcessor {
+
+    private final StandStorage standStorage;
+    private final TypeUrl type;
+
+    /* package */ AggregateQueryProcessor(StandStorage standStorage, TypeUrl type) {
+        this.standStorage = standStorage;
+        this.type = type;
+    }
+
+    private final Function<EntityId, AggregateStateId> stateIdTransformer = new Function<EntityId, AggregateStateId>() {
+        @Nullable
+        @Override
+        public AggregateStateId apply(@Nullable EntityId input) {
+            checkNotNull(input);
+
+            final Any rawId = input.getId();
+            final Message unpackedId = AnyPacker.unpack(rawId);
+            final AggregateStateId stateId = AggregateStateId.of(unpackedId, type);
+            return stateId;
+        }
+    };
+
+    @Override
+    public ImmutableCollection<Any> process(Query query) {
+
+        final ImmutableList.Builder<Any> resultBuilder = ImmutableList.builder();
+
+        ImmutableCollection<EntityStorageRecord> stateRecords;
+        final Target target = query.getTarget();
+        final FieldMask fieldMask = query.getFieldMask();
+        final boolean shouldApplyFieldMask = !fieldMask.getPathsList()
+                                                       .isEmpty();
+        if (target.getIncludeAll()) {
+            stateRecords = shouldApplyFieldMask
+                           ? standStorage.readAllByType(type, fieldMask)
+                           : standStorage.readAllByType(type);
+        } else {
+            stateRecords = doFetchWithFilters(target, fieldMask);
+        }
+
+        for (EntityStorageRecord record : stateRecords) {
+            final Any state = record.getState();
+            resultBuilder.add(state);
+        }
+
+        final ImmutableList<Any> result = resultBuilder.build();
+        return result;
+    }
+
+    private ImmutableCollection<EntityStorageRecord> doFetchWithFilters(Target target, FieldMask fieldMask) {
+        ImmutableCollection<EntityStorageRecord> result;
+        final EntityFilters filters = target.getFilters();
+        final boolean shouldApplyFieldMask = !fieldMask.getPathsList()
+                                                       .isEmpty();
+        final boolean idsAreDefined = !filters.getIdFilter()
+                                              .getIdsList()
+                                              .isEmpty();
+        if (idsAreDefined) {
+            final EntityIdFilter idFilter = filters.getIdFilter();
+            final Collection<AggregateStateId> stateIds = Collections2.transform(idFilter.getIdsList(),
+                                                                                 stateIdTransformer);
+            if (stateIds.size() == 1) {
+                // no need to trigger bulk reading.
+                // may be more effective, as bulk reading implies additional time and performance expenses.
+                final AggregateStateId singleId = stateIds.iterator()
+                                                          .next();
+                final EntityStorageRecord singleResult = shouldApplyFieldMask
+                                                         ? standStorage.read(singleId, fieldMask)
+                                                         : standStorage.read(singleId);
+                result = ImmutableList.of(singleResult);
+            } else {
+                result = handleBulkRead(stateIds, fieldMask, shouldApplyFieldMask);
+            }
+        } else {
+            result = ImmutableList.of();
+        }
+        return result;
+    }
+
+    private ImmutableCollection<EntityStorageRecord> handleBulkRead(Collection<AggregateStateId> stateIds,
+                                                                    FieldMask fieldMask,
+                                                                    boolean applyFieldMask) {
+        ImmutableCollection<EntityStorageRecord> result;
+        final Iterable<EntityStorageRecord> bulkReadResults = applyFieldMask
+                                                              ? standStorage.readMultiple(stateIds, fieldMask)
+                                                              : standStorage.readMultiple(stateIds);
+        result = FluentIterable.from(bulkReadResults)
+                               .filter(new Predicate<EntityStorageRecord>() {
+                                   @Override
+                                   public boolean apply(@Nullable EntityStorageRecord input) {
+                                       return input != null;
+                                   }
+                               })
+                               .toList();
+        return result;
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/stand/AggregateStateId.java b/server/src/main/java/org/spine3/server/stand/AggregateStateId.java
new file mode 100644
index 00000000000..2696d039254
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/AggregateStateId.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import org.spine3.protobuf.TypeUrl;
+
+import javax.annotation.CheckReturnValue;
+
+/**
+ * An identifier for the state of a certain {@link org.spine3.server.aggregate.Aggregate}.
+ *
+ * <p>{@code Aggregate} state is defined by {@link org.spine3.protobuf.TypeUrl}.
+ *
+ * <p>The {@code AggregateStateId} is used to store and access the latest {@code Aggregate} states in a {@link Stand}.
+ *
+ * @param <I> the type for IDs of the source aggregate
+ * @author Alex Tymchenko
+ */
+public final class AggregateStateId<I> {
+    private final I aggregateId;
+    private final TypeUrl stateType;
+
+    private AggregateStateId(I aggregateId, TypeUrl stateType) {
+        this.aggregateId = aggregateId;
+        this.stateType = stateType;
+    }
+
+    @CheckReturnValue
+    public static <I> AggregateStateId of(I aggregateId, TypeUrl stateType) {
+        return new AggregateStateId<I>(aggregateId, stateType);
+    }
+
+    public I getAggregateId() {
+        return aggregateId;
+    }
+
+    public TypeUrl getStateType() {
+        return stateType;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof AggregateStateId)) {
+            return false;
+        }
+        AggregateStateId<?> that = (AggregateStateId<?>) o;
+        return Objects.equal(aggregateId, that.aggregateId) &&
+                Objects.equal(stateType, that.stateType);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(aggregateId, stateType);
+    }
+
+    @Override
+    public String toString() {
+        return MoreObjects.toStringHelper(this)
+                          .add("aggregateId", aggregateId)
+                          .add("stateType", stateType)
+                          .toString();
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/stand/EntityQueryProcessor.java b/server/src/main/java/org/spine3/server/stand/EntityQueryProcessor.java
new file mode 100644
index 00000000000..c99de0bcb5f
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/EntityQueryProcessor.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.Any;
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.Message;
+import org.spine3.client.EntityFilters;
+import org.spine3.client.Query;
+import org.spine3.client.Target;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.server.entity.Entity;
+import org.spine3.server.entity.EntityRepository;
+
+/**
+ * Processes the queries targeting {@link org.spine3.server.entity.Entity} objects.
+ *
+ * @author Alex Tymchenko
+ */
+/* package */ class EntityQueryProcessor implements QueryProcessor {
+
+    private final EntityRepository<?, ? extends Entity, ? extends Message> repository;
+
+    /* package */ EntityQueryProcessor(EntityRepository<?, ? extends Entity, ? extends Message> repository) {
+        this.repository = repository;
+    }
+
+    @Override
+    public ImmutableCollection<Any> process(Query query) {
+        final ImmutableList.Builder<Any> resultBuilder = ImmutableList.builder();
+
+        final Target target = query.getTarget();
+        final FieldMask fieldMask = query.getFieldMask();
+
+        final ImmutableCollection<? extends Entity> entities;
+        if (target.getIncludeAll() && fieldMask.getPathsList()
+                                               .isEmpty()) {
+            entities = repository.loadAll();
+        } else {
+            final EntityFilters filters = target.getFilters();
+            entities = repository.find(filters, fieldMask);
+        }
+
+        for (Entity entity : entities) {
+            final Message state = entity.getState();
+            final Any packedState = AnyPacker.pack(state);
+            resultBuilder.add(packedState);
+        }
+
+        final ImmutableList<Any> result = resultBuilder.build();
+        return result;
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/stand/NoopQueryProcessor.java b/server/src/main/java/org/spine3/server/stand/NoopQueryProcessor.java
new file mode 100644
index 00000000000..f67eb2d7250
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/NoopQueryProcessor.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.Any;
+import org.spine3.client.Query;
+
+/**
+ * An {@link QueryProcessor} implementation that always returns empty result.
+ *
+ * <p>Used to define a processing result for {@link Query} which does not hit any of exposed state objects.
+ *
+ * @author Alex Tymchenko
+ */
+/* package */ class NoopQueryProcessor implements QueryProcessor {
+    @Override
+    public ImmutableCollection<Any> process(Query query) {
+        return ImmutableList.of();
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/stand/QueryProcessor.java b/server/src/main/java/org/spine3/server/stand/QueryProcessor.java
new file mode 100644
index 00000000000..80fc5cb028d
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/QueryProcessor.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.protobuf.Any;
+import io.grpc.stub.StreamObserver;
+import org.spine3.client.Query;
+
+/**
+ * Processes a query and returns the result.
+ *
+ * @author Alex Tymchenko
+ */
+/* package */ interface QueryProcessor {
+
+    /**
+     * Performs query processing as a part of {@link Stand#execute(Query, StreamObserver)}.
+     *
+     * @param query an instance of {@code Query} to process
+     * @return the query result
+     */
+    ImmutableCollection<Any> process(Query query);
+}
diff --git a/server/src/main/java/org/spine3/server/stand/Stand.java b/server/src/main/java/org/spine3/server/stand/Stand.java
new file mode 100644
index 00000000000..bdd44151319
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/Stand.java
@@ -0,0 +1,415 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import com.google.protobuf.Message;
+import io.grpc.stub.StreamObserver;
+import org.spine3.base.Queries;
+import org.spine3.base.Responses;
+import org.spine3.client.Query;
+import org.spine3.client.QueryResponse;
+import org.spine3.client.Subscription;
+import org.spine3.client.Target;
+import org.spine3.protobuf.Timestamps;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.aggregate.AggregateRepository;
+import org.spine3.server.entity.Entity;
+import org.spine3.server.entity.EntityRepository;
+import org.spine3.server.entity.Repository;
+import org.spine3.server.storage.EntityStorageRecord;
+import org.spine3.server.storage.StandStorage;
+import org.spine3.server.storage.memory.InMemoryStandStorage;
+
+import javax.annotation.CheckReturnValue;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.Executor;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * A container for storing the lastest {@link org.spine3.server.aggregate.Aggregate} states.
+ *
+ * <p>Provides an optimal way to access the latest state of published aggregates for read-side services.
+ * The aggregate states are delivered to the instance of {@code Stand} through {@link StandFunnel}
+ * from {@link org.spine3.server.aggregate.AggregateRepository} instances.
+ *
+ * <p>In order to provide a flexibility in defining data access policies, {@code Stand} contains only the states
+ * of published aggregates. Please refer to {@link org.spine3.server.aggregate.Aggregate} for publication description.
+ *
+ * <p>Each {@link org.spine3.server.BoundedContext} contains the only instance of {@code Stand}.
+ *
+ * @author Alex Tymchenko
+ */
+public class Stand implements AutoCloseable {
+
+    /**
+     * Persistent storage for the latest {@link org.spine3.server.aggregate.Aggregate} states.
+     *
+     * <p>Any {@code Aggregate} state delivered to this instance of {@code Stand} is persisted to this storage.
+     */
+    private final StandStorage storage;
+
+    /**
+     * Manages the subscriptions for this instance of {@code Stand}.
+     */
+    private final SubscriptionRegistry subscriptionRegistry = new SubscriptionRegistry();
+
+    /**
+     * An instance of executor used to invoke callbacks
+     */
+    private final Executor callbackExecutor;
+
+    /**
+     * The mapping between {@code TypeUrl} instances and repositories providing the entities of this type
+     */
+    private final ConcurrentMap<TypeUrl,
+            EntityRepository<?, ? extends Entity, ? extends Message>> typeToRepositoryMap = new ConcurrentHashMap<>();
+
+    /**
+     * Stores  known {@link org.spine3.server.aggregate.Aggregate} types in order to distinguish them among all
+     * instances of {@code TypeUrl}.
+     *
+     * <p>Once this instance of {@code Stand} receives an update as {@link Any}, the {@code Aggregate} states
+     * are persisted for further usage. The entities that are not {@code Aggregate} are not persisted,
+     * and only propagated to the registered callbacks.
+     */
+    private final Set<TypeUrl> knownAggregateTypes = Sets.newConcurrentHashSet();
+
+    /**
+     * Used to return an empty result collection for {@link Query}.
+     */
+    private static final QueryProcessor NOOP_PROCESSOR = new NoopQueryProcessor();
+
+    private Stand(Builder builder) {
+        storage = builder.getStorage();
+        callbackExecutor = builder.getCallbackExecutor();
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    /**
+     * Update the state of an entity inside of the current instance of {@code Stand}.
+     *
+     * <p>In case the entity update represents the new {@link org.spine3.server.aggregate.Aggregate} state,
+     * store the new value for the {@code Aggregate} to each of the configured instances of {@link StandStorage}.
+     *
+     * <p>Each {@code Aggregate } state value is stored as one-to-one to its {@link org.spine3.protobuf.TypeUrl}
+     * obtained via {@link Any#getTypeUrl()}.
+     *
+     * <p>In case {@code Stand} already contains the state for this {@code Aggregate}, the value will be replaced.
+     *
+     * <p>The state updates which are not originated from the {@code Aggregate} are not stored in the {@code Stand}.
+     *
+     * <p>In any case, the state update is then propagated to the callbacks. The set of matched callbacks
+     * is determined by filtering all the registered callbacks by the entity {@code TypeUrl}.
+     *
+     * <p>The matching callbacks are executed with the {@link #callbackExecutor}.
+     *
+     * @param id          the entity identifier
+     * @param entityState the entity state
+     */
+    /* package */ void update(Object id, Any entityState) {
+        final String typeUrlString = entityState.getTypeUrl();
+        final TypeUrl typeUrl = TypeUrl.of(typeUrlString);
+
+        final boolean isAggregateUpdate = knownAggregateTypes.contains(typeUrl);
+
+        if (isAggregateUpdate) {
+            final AggregateStateId aggregateStateId = AggregateStateId.of(id, typeUrl);
+
+            final EntityStorageRecord record = EntityStorageRecord.newBuilder()
+                                                                  .setState(entityState)
+                                                                  .setWhenModified(Timestamps.getCurrentTime())
+                                                                  .build();
+            storage.write(aggregateStateId, record);
+        }
+
+        notifyMatchingSubscriptions(id, entityState, typeUrl);
+    }
+
+    /**
+     * Subscribe for all further changes of an entity state, which satisfies the {@link Target}.
+     *
+     * <p>Once this instance of {@code Stand} receives an update of an entity with the given {@code TypeUrl},
+     * all such callbacks are executed.
+     *
+     * @param target an instance {@link Target}, defining the entity and criteria,
+     *               which changes should be propagated to the {@code callback}
+     */
+    @CheckReturnValue
+    public Subscription subscribe(Target target) {
+        final Subscription subscription = subscriptionRegistry.addSubscription(target);
+        return subscription;
+    }
+
+    /**
+     * Activate the subscription created via {@link #subscribe(Target)}.
+     *
+     * <p>After the activation, the clients will start receiving the updates via {@code EntityUpdateCallback}
+     * upon the changes in the entities, defined by the {@code Target} attribute used for this subscription.
+     *
+     * @param subscription the subscription to activate.
+     * @param callback     an instance of {@link EntityUpdateCallback} executed upon entity update.
+     * @see #subscribe(Target)
+     */
+    public void activate(Subscription subscription, EntityUpdateCallback callback) {
+        subscriptionRegistry.activate(subscription, callback);
+    }
+
+    /**
+     * Cancel the {@link Subscription}.
+     *
+     * <p>Typically invoked to cancel the previous {@link #activate(Subscription, EntityUpdateCallback)} call.
+     * <p>After this method is called, the subscribers stop receiving the updates,
+     * related to the given {@code Subscription}.
+     *
+     * @param subscription a subscription to cancel.
+     */
+    public void cancel(Subscription subscription) {
+        subscriptionRegistry.removeSubscription(subscription);
+    }
+
+    /**
+     * Read all {@link Entity} types exposed for reading by this instance of {@code Stand}.
+     *
+     * <p>Use {@link Stand#registerTypeSupplier(Repository)} to expose a type.
+     *
+     * <p>The result includes all values from {@link #getExposedAggregateTypes()} as well.
+     *
+     * @return the set of types as {@link TypeUrl} instances
+     */
+    @CheckReturnValue
+    public ImmutableSet<TypeUrl> getExposedTypes() {
+        final ImmutableSet.Builder<TypeUrl> resultBuilder = ImmutableSet.builder();
+        final Set<TypeUrl> projectionTypes = typeToRepositoryMap.keySet();
+        resultBuilder.addAll(projectionTypes)
+                     .addAll(knownAggregateTypes);
+        final ImmutableSet<TypeUrl> result = resultBuilder.build();
+        return result;
+    }
+
+    /**
+     * Read all {@link org.spine3.server.aggregate.Aggregate} entity types exposed for reading
+     * by this instance of {@code Stand}.
+     *
+     * <p>Use {@link Stand#registerTypeSupplier(Repository)} to expose an {@code Aggregate} type.
+     *
+     * @return the set of types as {@link TypeUrl} instances
+     */
+    @CheckReturnValue
+    public ImmutableSet<TypeUrl> getExposedAggregateTypes() {
+        final ImmutableSet<TypeUrl> result = ImmutableSet.copyOf(knownAggregateTypes);
+        return result;
+    }
+
+    /**
+     * Read a particular set of items from the read-side of the application and feed the result into an instance
+     *
+     * <p>{@link Query} defines the query target and the expected detail level for response.
+     *
+     * <p>The query results are fed to an instance of {@link StreamObserver<QueryResponse>}.
+     *
+     * @param query            an instance of query
+     * @param responseObserver an observer to feed the query results to.
+     */
+    public void execute(Query query, StreamObserver<QueryResponse> responseObserver) {
+
+        final TypeUrl type = Queries.typeOf(query);
+        checkNotNull(type, "Query target type unknown");
+        final QueryProcessor queryProcessor = processorFor(type);
+
+        final ImmutableCollection<Any> readResult = queryProcessor.process(query);
+        final QueryResponse response = QueryResponse.newBuilder()
+                                                    .addAllMessages(readResult)
+                                                    .setResponse(Responses.ok())
+                                                    .build();
+        responseObserver.onNext(response);
+        responseObserver.onCompleted();
+    }
+
+    private void notifyMatchingSubscriptions(Object id, final Any entityState, TypeUrl typeUrl) {
+        if (subscriptionRegistry.hasType(typeUrl)) {
+            final Set<SubscriptionRecord> allRecords = subscriptionRegistry.byType(typeUrl);
+
+            for (final SubscriptionRecord subscriptionRecord : allRecords) {
+
+                final boolean subscriptionIsActive = subscriptionRecord.isActive();
+                final boolean stateMatches = subscriptionRecord.matches(typeUrl, id, entityState);
+                if (subscriptionIsActive && stateMatches) {
+                    callbackExecutor.execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            subscriptionRecord.getCallback()
+                                              .onStateChanged(entityState);
+                        }
+                    });
+                }
+            }
+        }
+    }
+
+    /**
+     * Register a supplier for the objects of a certain {@link TypeUrl} to be able
+     * to read them in response to a {@link org.spine3.client.Query}.
+     *
+     * <p>In case the supplier is an instance of {@link AggregateRepository}, the {@code Repository} is not registered
+     * as type supplier, since the {@code Aggregate} reads are performed by accessing
+     * the latest state in the supplied {@code StandStorage}.
+     *
+     * <p>However, the type of the {@code AggregateRepository} instance is recorded for the postponed processing
+     * of updates.
+     *
+     * @see #update(Object, Any)
+     */
+    @SuppressWarnings("ChainOfInstanceofChecks")
+    public <I, E extends Entity<I, ?>> void registerTypeSupplier(Repository<I, E> repository) {
+        final TypeUrl entityType = repository.getEntityStateType();
+
+        if (repository instanceof EntityRepository) {
+            typeToRepositoryMap.put(entityType, (EntityRepository<I, E, ? extends Message>) repository);
+        }
+        if (repository instanceof AggregateRepository) {
+            knownAggregateTypes.add(entityType);
+        }
+    }
+
+    /**
+     * Dumps all {@link TypeUrl}-to-{@link EntityRepository} relations.
+     */
+    @Override
+    public void close() throws Exception {
+        typeToRepositoryMap.clear();
+        storage.close();
+    }
+
+    /**
+     * A contract for the callbacks to be executed upon entity state change.
+     *
+     * @see #activate(Subscription, EntityUpdateCallback)
+     * @see #cancel(Subscription)
+     */
+    public interface EntityUpdateCallback {
+
+        /**
+         * Called when a certain entity state is updated.
+         *
+         * @param newEntityState new state of the entity
+         */
+        void onStateChanged(Any newEntityState);
+    }
+
+    /**
+     * Factory method which determines a proper {@link QueryProcessor} implementation depending on {@link TypeUrl}
+     * of the incoming {@link Query#getTarget()}.
+     *
+     * <p>As {@code Stand} accumulates the read-side updates from various repositories, the {@code Query} processing
+     * varies a lot. The target type of the incoming {@code Query} tells the {@code Stand} about the essence of the
+     * object queried. Thus making it possible to pick a proper strategy for data fetch.
+     *
+     * @param type the target type of the {@code Query}
+     * @return suitable implementation of {@code QueryProcessor}
+     */
+    private QueryProcessor processorFor(TypeUrl type) {
+        final QueryProcessor result;
+
+        final EntityRepository<?, ? extends Entity, ? extends Message> repository = typeToRepositoryMap.get(type);
+        if (repository != null) {
+
+            // The query target is an {@code Entity}.
+            result = new EntityQueryProcessor(repository);
+        } else if (getExposedAggregateTypes().contains(type)) {
+
+            // The query target is an {@code Aggregate} state.
+            result = new AggregateQueryProcessor(storage, type);
+        } else {
+
+            // This type points to an objects, that are not exposed via the current instance of {@code Stand}.
+            result = NOOP_PROCESSOR;
+        }
+        return result;
+    }
+
+    public static class Builder {
+        private StandStorage storage;
+        private Executor callbackExecutor;
+
+        /**
+         * Set an instance of {@link StandStorage} to be used to persist the latest an Aggregate states.
+         *
+         * <p>If no {@code storage} is assigned, the {@link InMemoryStandStorage} is be set by default.
+         *
+         * @param storage an instance of {@code StandStorage}
+         * @return this instance of {@code Builder}
+         */
+        public Builder setStorage(StandStorage storage) {
+            this.storage = storage;
+            return this;
+        }
+
+        public Executor getCallbackExecutor() {
+            return callbackExecutor;
+        }
+
+        /**
+         * Set an {@code Executor} to be used for executing callback methods.
+         *
+         * <p>If the {@code Executor} is not set, {@link MoreExecutors#directExecutor()} will be used.
+         *
+         * @param callbackExecutor the instance of {@code Executor}
+         * @return this instance of {@code Builder}
+         */
+        public Builder setCallbackExecutor(Executor callbackExecutor) {
+            this.callbackExecutor = callbackExecutor;
+            return this;
+        }
+
+        public StandStorage getStorage() {
+            return storage;
+        }
+
+        /**
+         * Build an instance of {@code Stand}.
+         *
+         * @return the instance of Stand
+         */
+        public Stand build() {
+            if (storage == null) {
+                storage = InMemoryStandStorage.newBuilder()
+                                              .build();
+            }
+            if (callbackExecutor == null) {
+                callbackExecutor = MoreExecutors.directExecutor();
+            }
+
+            final Stand result = new Stand(this);
+            return result;
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/spine3/server/stand/StandFunnel.java b/server/src/main/java/org/spine3/server/stand/StandFunnel.java
new file mode 100644
index 00000000000..3292ec0b338
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/StandFunnel.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import org.spine3.Internal;
+import org.spine3.base.Command;
+import org.spine3.base.Event;
+
+import java.util.concurrent.Executor;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+/**
+ * Delivers the latest {@link org.spine3.server.entity.Entity} states from the {@code Entity} repositories
+ * to the {@link Stand}.
+ *
+ * <p>Note: Unlike {@link org.spine3.server.event.EventBus} and {@link org.spine3.server.command.CommandBus},
+ * which assume many publishers and many subscribers, the funnel may have zero or more publishers (typically, instances
+ * of {@link org.spine3.server.aggregate.AggregateRepository} or {@link org.spine3.server.projection.ProjectionRepository}),
+ * but the only subscriber, the instance of {@code Stand}.
+ *
+ * <p>In scope of a single {@link org.spine3.server.BoundedContext} there can be the only instance of {@code StandFunnel}.
+ *
+ * @author Alex Tymchenko
+ * @see org.spine3.server.aggregate.AggregateRepository#dispatch(Command)
+ * @see org.spine3.server.projection.ProjectionRepository#dispatch(Event)
+ */
+@Internal
+public class StandFunnel {
+
+    /**
+     * The instance of {@link Stand} to deliver the {@code Entity} state updates to.
+     */
+    private final Stand stand;
+
+    /**
+     * An {@link Executor} used for execution of data delivery methods.
+     */
+    private final Executor executor;
+
+    private StandFunnel(Builder builder) {
+        this.stand = builder.getStand();
+        this.executor = builder.getExecutor();
+    }
+
+    /**
+     * Post the state of an {@link org.spine3.server.entity.Entity} to an instance of {@link Stand}.
+     *
+     * <p>The state data is posted as {@link Any} to allow transferring over the network.
+     *
+     * @param id          the id of an entity
+     * @param entityState the state of an {@code Entity}
+     */
+    public void post(final Object id, final Any entityState) {
+        executor.execute(new Runnable() {
+            @Override
+            public void run() {
+                stand.update(id, entityState);
+            }
+        });
+    }
+
+    /**
+     * Create a new {@code Builder} for {@link StandFunnel}.
+     *
+     * @return a new {@code Builder} instance.
+     */
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    public static class Builder {
+
+        /**
+         * The target {@code Stand} to deliver the {@code Entity} updates to.
+         */
+        private Stand stand;
+
+        /**
+         * Optional {@code Executor} for delivering the data to {@code Stand}.
+         *
+         * <p>If not set, a {@link MoreExecutors#directExecutor()} value will be set by the builder.
+         */
+        private Executor executor;
+
+        public Stand getStand() {
+            return stand;
+        }
+
+        /**
+         * Set the {@link Stand} instance for this {@code StandFunnel}.
+         *
+         * <p> The value must not be null.
+         *
+         * @param stand the instance of {@link Stand}.
+         * @return {@code this} instance of {@code Builder}
+         */
+        public Builder setStand(Stand stand) {
+            this.stand = checkNotNull(stand);
+            return this;
+        }
+
+        public Executor getExecutor() {
+            return executor;
+        }
+
+        /**
+         * Set the {@code Executor} instance for this {@code StandFunnel}.
+         *
+         * <p>The value must not be {@code null}.
+         *
+         * <p> If this method is not used, a {@link MoreExecutors#directExecutor()} value will be used.
+         *
+         * @param executor the instance of {@code Executor}.
+         * @return {@code this} instance of {@code Builder}
+         */
+        public Builder setExecutor(Executor executor) {
+            this.executor = checkNotNull(executor);
+            return this;
+        }
+
+        public StandFunnel build() {
+            checkState(stand != null, "Stand must be defined for the funnel");
+
+            if (executor == null) {
+                executor = MoreExecutors.directExecutor();
+            }
+
+            final StandFunnel result = new StandFunnel(this);
+            return result;
+        }
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/stand/SubscriptionRecord.java b/server/src/main/java/org/spine3/server/stand/SubscriptionRecord.java
new file mode 100644
index 00000000000..5c23c0ca4ee
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/SubscriptionRecord.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.base.Objects;
+import com.google.protobuf.Any;
+import org.spine3.base.Identifiers;
+import org.spine3.client.EntityFilters;
+import org.spine3.client.EntityId;
+import org.spine3.client.EntityIdFilter;
+import org.spine3.client.Subscription;
+import org.spine3.client.Target;
+import org.spine3.protobuf.TypeUrl;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+/**
+ * Represents the attributes of a single subscription.
+ *
+ * @see SubscriptionRegistry
+ */
+/* package */ final class SubscriptionRecord {
+    private final Subscription subscription;
+    private final Target target;
+    private final TypeUrl type;
+
+    /**
+     * The {@code callback} is null after the creation and until the subscription is activated.
+     *
+     * @see SubscriptionRegistry#addSubscription(Target)
+     * @see SubscriptionRegistry#activate(Subscription, Stand.EntityUpdateCallback)
+     */
+    @Nullable
+    private Stand.EntityUpdateCallback callback = null;
+
+    /* package */ SubscriptionRecord(Subscription subscription, Target target, TypeUrl type) {
+        this.subscription = subscription;
+        this.target = target;
+        this.type = type;
+    }
+
+    /**
+     * Attach an activation callback to this record.
+     *
+     * @param callback the callback to attach
+     */
+    /* package */ void activate(Stand.EntityUpdateCallback callback) {
+        this.callback = callback;
+    }
+
+    /**
+     * Checks whether this record has a callback attached.
+     */
+    /* package */ boolean isActive() {
+        final boolean result = this.callback != null;
+        return result;
+    }
+
+    /**
+     * Checks whether this record matches the given parameters.
+     *
+     * @param type        the type to match
+     * @param id          the ID to match
+     * @param entityState the entity state to match
+     * @return {@code true} if this record matches all the given parameters, {@code false} otherwise.
+     */
+    /* package */ boolean matches(TypeUrl type,
+                                  Object id,
+                                  // entityState will be later used for more advanced filtering
+                                  @SuppressWarnings("UnusedParameters") Any entityState) {
+        final boolean result;
+
+        final boolean typeMatches = this.type.equals(type);
+        if (typeMatches) {
+            final boolean includeAll = target.getIncludeAll();
+            final EntityFilters filters = target.getFilters();
+            result = includeAll || matchByFilters(id, filters);
+        } else {
+            result = false;
+        }
+        return result;
+    }
+
+    private static boolean matchByFilters(Object id, EntityFilters filters) {
+        final boolean result;
+        final EntityIdFilter givenIdFilter = filters.getIdFilter();
+        final boolean idFilterSet = !EntityIdFilter.getDefaultInstance()
+                                                   .equals(givenIdFilter);
+        if (idFilterSet) {
+            final Any idAsAny = Identifiers.idToAny(id);
+            final EntityId givenEntityId = EntityId.newBuilder()
+                                                   .setId(idAsAny)
+                                                   .build();
+            final List<EntityId> idsList = givenIdFilter.getIdsList();
+            result = idsList.contains(givenEntityId);
+        } else {
+            result = false;
+        }
+        return result;
+    }
+
+    /* package */ TypeUrl getType() {
+        return type;
+    }
+
+    /* package */ Stand.EntityUpdateCallback getCallback() {
+        return callback;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof SubscriptionRecord)) {
+            return false;
+        }
+        SubscriptionRecord that = (SubscriptionRecord) o;
+        return Objects.equal(subscription, that.subscription);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(subscription);
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/stand/SubscriptionRegistry.java b/server/src/main/java/org/spine3/server/stand/SubscriptionRegistry.java
new file mode 100644
index 00000000000..40adecdd743
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/SubscriptionRegistry.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import org.spine3.base.Identifiers;
+import org.spine3.client.Subscription;
+import org.spine3.client.Target;
+import org.spine3.protobuf.TypeUrl;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.Maps.newHashMap;
+
+/**
+ * Registry for subscription management.
+ *
+ * <p>Provides a quick access to the subscription records by {@link TypeUrl}.
+ *
+ * <p>Responsible for {@link Subscription} object instantiation.
+ *
+ * @author Alex Tymchenko
+ */
+/* package */ final class SubscriptionRegistry {
+    private final Map<TypeUrl, Set<SubscriptionRecord>> typeToAttrs = newHashMap();
+    private final Map<Subscription, SubscriptionRecord> subscriptionToAttrs = newHashMap();
+
+    /**
+     * Activate the subscription with the passed callback.
+     *
+     * <p>The callback passed will become associated with the subscription.
+     *
+     * @param subscription the subscription to activate
+     * @param callback     the callback to make active
+     */
+    /* package */
+    synchronized void activate(Subscription subscription, Stand.EntityUpdateCallback callback) {
+        checkState(subscriptionToAttrs.containsKey(subscription),
+                   "Cannot find the subscription in the registry.");
+        final SubscriptionRecord subscriptionRecord = subscriptionToAttrs.get(subscription);
+        subscriptionRecord.activate(callback);
+    }
+
+    /**
+     * Creates a subscription for the passed {@code Target} and adds it to the registry.
+     *
+     * @param target the target for a new subscription
+     * @return the created subscription
+     */
+    /* package */
+    synchronized Subscription addSubscription(Target target) {
+        final String subscriptionId = Identifiers.newUuid();
+        final String typeAsString = target.getType();
+        final TypeUrl type = TypeUrl.of(typeAsString);
+        final Subscription subscription = Subscription.newBuilder()
+                                                      .setId(subscriptionId)
+                                                      .setType(typeAsString)
+                                                      .build();
+        final SubscriptionRecord attributes = new SubscriptionRecord(subscription, target, type);
+
+        if (!typeToAttrs.containsKey(type)) {
+            typeToAttrs.put(type, new HashSet<SubscriptionRecord>());
+        }
+        typeToAttrs.get(type)
+                   .add(attributes);
+
+        subscriptionToAttrs.put(subscription, attributes);
+        return subscription;
+    }
+
+    /**
+     * Remove the subscription from this registry.
+     *
+     * <p>If there is no such subscription in this instance of {@code SubscriptionRegistry}, invocation has no effect.
+     *
+     * @param subscription the subscription to remove
+     */
+    /* package */
+    synchronized void removeSubscription(Subscription subscription) {
+        if (!subscriptionToAttrs.containsKey(subscription)) {
+            return;
+        }
+        final SubscriptionRecord attributes = subscriptionToAttrs.get(subscription);
+
+        if (typeToAttrs.containsKey(attributes.getType())) {
+            typeToAttrs.get(attributes.getType())
+                       .remove(attributes);
+        }
+        subscriptionToAttrs.remove(subscription);
+    }
+
+    /**
+     * Filter the registered {@link SubscriptionRecord}s by their type.
+     *
+     * @param type the type to filter by
+     * @return the collection of filtered records
+     */
+    /* package */
+    synchronized Set<SubscriptionRecord> byType(TypeUrl type) {
+        final Set<SubscriptionRecord> result = typeToAttrs.get(type);
+        return result;
+    }
+
+    /**
+     * Checks whether the current registry has the records related to a given type.
+     *
+     * @param type the type to check records for
+     * @return {@code true} if there are records with the given type, {@code false} otherwise
+     */
+    /* package */
+    synchronized boolean hasType(TypeUrl type) {
+        final boolean result = typeToAttrs.containsKey(type);
+        return result;
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/stand/package-info.java b/server/src/main/java/org/spine3/server/stand/package-info.java
new file mode 100644
index 00000000000..c2d66c7cf5f
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/stand/package-info.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * This package provides classes for working with Stand.
+ */
+
+@SPI
+@ParametersAreNonnullByDefault
+package org.spine3.server.stand;
+
+import org.spine3.SPI;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/server/src/main/java/org/spine3/server/storage/AggregateStorage.java b/server/src/main/java/org/spine3/server/storage/AggregateStorage.java
index 6023c2dc52b..19b3609c860 100644
--- a/server/src/main/java/org/spine3/server/storage/AggregateStorage.java
+++ b/server/src/main/java/org/spine3/server/storage/AggregateStorage.java
@@ -37,7 +37,7 @@
 import static com.google.protobuf.TextFormat.shortDebugString;
 import static org.spine3.base.Identifiers.idToString;
 import static org.spine3.protobuf.TypeUrl.ofEnclosed;
-import static org.spine3.validate.Validate.checkIsPositive;
+import static org.spine3.validate.Validate.checkPositive;
 import static org.spine3.validate.Validate.checkNotEmptyOrBlank;
 
 /**
@@ -49,7 +49,8 @@
 @SPI
 public abstract class AggregateStorage<I> extends AbstractStorage<I, AggregateEvents> {
 
-    private static final String SNAPSHOT_TYPE_NAME = Snapshot.getDescriptor().getName();
+    private static final String SNAPSHOT_TYPE_NAME = Snapshot.getDescriptor()
+                                                             .getName();
 
     protected AggregateStorage(boolean multitenant) {
         super(multitenant);
@@ -79,7 +80,7 @@ public AggregateEvents read(I aggregateId) {
                     break;
                 case KIND_NOT_SET:
                     throw new IllegalStateException("Event or snapshot missing in record: \"" +
-                            shortDebugString(record) + '\"');
+                                                            shortDebugString(record) + '\"');
             }
         }
 
@@ -97,9 +98,9 @@ public AggregateEvents read(I aggregateId) {
      *
      * <p>NOTE: does not rewrite any events. Several events can be associated with one aggregate ID.
      *
-     * @param id the ID for the record
+     * @param id     the ID for the record
      * @param events events to store
-     * @throws IllegalStateException if the storage is closed
+     * @throws IllegalStateException    if the storage is closed
      * @throws IllegalArgumentException if event list is empty
      */
     @Override
@@ -112,14 +113,14 @@ public void write(I id, AggregateEvents events) throws IllegalStateException, Il
 
         for (final Event event : eventList) {
             final AggregateStorageRecord record = toStorageRecord(event);
-            writeInternal(id, record);
+            writeRecord(id, record);
         }
     }
 
     /**
      * Writes an event to the storage by an aggregate ID.
      *
-     * @param id the aggregate ID
+     * @param id    the aggregate ID
      * @param event the event to write
      * @throws IllegalStateException if the storage is closed
      */
@@ -129,29 +130,31 @@ public void writeEvent(I id, Event event) {
         checkNotNull(event);
 
         final AggregateStorageRecord record = toStorageRecord(event);
-        writeInternal(id, record);
+        writeRecord(id, record);
     }
 
     /**
      * Writes a {@code snapshot} by an {@code aggregateId} to the storage.
      *
      * @param aggregateId an ID of an aggregate of which the snapshot is made
-     * @param snapshot the snapshot of the aggregate
+     * @param snapshot    the snapshot of the aggregate
      * @throws IllegalStateException if the storage is closed
      */
     public void write(I aggregateId, Snapshot snapshot) {
         checkNotClosed();
         checkNotNull(aggregateId);
         checkNotNull(snapshot);
-
-        final AggregateStorageRecord record = AggregateStorageRecord.newBuilder()
-                .setTimestamp(checkIsPositive(snapshot.getTimestamp(), "Snapshot timestamp"))
-                .setEventType(SNAPSHOT_TYPE_NAME)
-                .setEventId("") // No event ID for snapshots because it's not a domain event.
-                .setVersion(snapshot.getVersion())
-                .setSnapshot(snapshot)
-                .build();
-        writeInternal(aggregateId, record);
+        final Timestamp timestamp = checkPositive(snapshot.getTimestamp(), "Snapshot timestamp");
+
+        final AggregateStorageRecord record =
+                AggregateStorageRecord.newBuilder()
+                                      .setTimestamp(timestamp)
+                                      .setEventType(SNAPSHOT_TYPE_NAME)
+                                      .setEventId("") // No event ID for snapshots because it's not a domain event.
+                                      .setVersion(snapshot.getVersion())
+                                      .setSnapshot(snapshot)
+                                      .build();
+        writeRecord(aggregateId, record);
     }
 
     /**
@@ -162,16 +165,18 @@ public void write(I aggregateId, Snapshot snapshot) {
      * @return an even count after the last snapshot
      * @throws IllegalStateException if the storage is closed
      */
+    // TODO[alex.tymchenko]: make it `protected` after this Storage is moved to `aggregate` package.
     public abstract int readEventCountAfterLastSnapshot(I id);
 
     /**
      * Reads a count of events which were saved to the storage after the last snapshot was created,
      * or a count of all events if there were no snapshots yet.
      *
-     * @param id an ID of an aggregate
+     * @param id         an ID of an aggregate
      * @param eventCount an even count after the last snapshot
      * @throws IllegalStateException if the storage is closed
      */
+    // TODO[alex.tymchenko]: make it `protected` after this Storage is moved to `aggregate` package.
     public abstract void writeEventCountAfterLastSnapshot(I id, int eventCount);
 
     private static AggregateStorageRecord toStorageRecord(Event event) {
@@ -187,14 +192,14 @@ private static AggregateStorageRecord toStorageRecord(Event event) {
         final String eventType = ofEnclosed(eventMsg).getTypeName();
         checkNotEmptyOrBlank(eventType, "Event type");
 
-        final Timestamp timestamp = checkIsPositive(context.getTimestamp(), "Event time");
+        final Timestamp timestamp = checkPositive(context.getTimestamp(), "Event time");
 
         final AggregateStorageRecord.Builder builder = AggregateStorageRecord.newBuilder()
-                .setEvent(event)
-                .setTimestamp(timestamp)
-                .setEventId(eventIdStr)
-                .setEventType(eventType)
-                .setVersion(context.getVersion());
+                                                                             .setEvent(event)
+                                                                             .setTimestamp(timestamp)
+                                                                             .setEventId(eventIdStr)
+                                                                             .setEventType(eventType)
+                                                                             .setVersion(context.getVersion());
         return builder.build();
     }
 
@@ -203,10 +208,10 @@ private static AggregateStorageRecord toStorageRecord(Event event) {
     /**
      * Writes the passed record into the storage.
      *
-     * @param id the aggregate ID
+     * @param id     the aggregate ID
      * @param record the record to write
      */
-    protected abstract void writeInternal(I id, AggregateStorageRecord record);
+    protected abstract void writeRecord(I id, AggregateStorageRecord record);
 
     /**
      * Creates iterator of aggregate event history with the reverse traversal.
diff --git a/server/src/main/java/org/spine3/server/storage/BulkStorageOperationsMixin.java b/server/src/main/java/org/spine3/server/storage/BulkStorageOperationsMixin.java
new file mode 100644
index 00000000000..4c858c40a97
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/storage/BulkStorageOperationsMixin.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.storage;
+
+import com.google.protobuf.Message;
+
+import javax.annotation.CheckReturnValue;
+import java.util.Map;
+
+/**
+ * Mixin contract for storages providing bulk operations.
+ *
+ * <p>Defines the common API for storages, which are able to effectively implement bulk reads and writes.
+ *
+ * @param <I> a type for entity identifiers
+ * @param <R> stored record type
+ * @author Alex Tymchenko
+ */
+/* package */ interface BulkStorageOperationsMixin<I, R extends Message> {
+
+    /**
+     * Reads the records from the storage with the given IDs.
+     *
+     * <p>The size of {@link Iterable} returned is always the same as the size of given IDs.
+     *
+     * <p>In case there is no record for a particular ID, {@code null} will be present in the result instead.
+     * In this way {@code readMultiple()} callees are able to track the absenсe of a certain element by comparing
+     * the input IDs and resulting {@code Iterable}.
+     *
+     * <p>E.g. {@code readMultiple( Lists.newArrayList(idPresentInStorage, idNonPresentInStorage) )} will return
+     * an {@code Iterable} with two elements, first of which is non-null and the second is null.
+     *
+     * @param ids record IDs of interest
+     * @return the {@link Iterable} containing the records matching the given IDs
+     * @throws IllegalStateException if the storage was closed before
+     */
+    @CheckReturnValue
+    Iterable<R> readMultiple(Iterable<I> ids);
+
+
+    /**
+     * Reads all the records from the storage.
+     *
+     * <p>Each record is returned as a {@link Map} of record ID to the instance of a record.
+     * Such an approach enables turning the records into entities for callees.
+     *
+     * @return the {@code Map} containing the ID -> record entries.
+     * @throws IllegalStateException if the storage was closed before
+     */
+    @CheckReturnValue
+    Map<I, R> readAll();
+}
diff --git a/server/src/main/java/org/spine3/server/storage/EntityStorage.java b/server/src/main/java/org/spine3/server/storage/EntityStorage.java
deleted file mode 100644
index a473ec9d833..00000000000
--- a/server/src/main/java/org/spine3/server/storage/EntityStorage.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright 2016, TeamDev Ltd. All rights reserved.
- *
- * Redistribution and use in source and/or binary forms, with or without
- * modification, must retain the above copyright notice and the following
- * disclaimer.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package org.spine3.server.storage;
-
-import org.spine3.SPI;
-import org.spine3.server.entity.Entity;
-
-import javax.annotation.Nullable;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * An entity storage keeps messages with identity.
- *
- * @param <I> the type of entity IDs
- * @author Alexander Yevsyukov
- * @see Entity
- */
-@SPI
-public abstract class EntityStorage<I> extends AbstractStorage<I, EntityStorageRecord> {
-
-    protected EntityStorage(boolean multitenant) {
-        super(multitenant);
-    }
-
-    @Override
-    public EntityStorageRecord read(I id) {
-        checkNotClosed();
-        checkNotNull(id);
-
-        final EntityStorageRecord record = readInternal(checkNotNull(id));
-        if (record == null) {
-            return EntityStorageRecord.getDefaultInstance();
-        }
-        return record;
-    }
-
-    @Override
-    public void write(I id, EntityStorageRecord record) {
-        checkNotNull(id);
-        checkArgument(record.hasState(), "Record does not have state field.");
-        checkNotClosed();
-
-        writeInternal(id, record);
-    }
-
-    //
-    // Internal storage methods
-    //---------------------------
-
-    /**
-     * Reads a record from the storage by the passed ID.
-     *
-     * @param id the ID of the record to load
-     * @return a record instance or {@code null} if there is no record with this ID
-     */
-    @Nullable
-    protected abstract EntityStorageRecord readInternal(I id);
-
-    /**
-     * Writes a record into the storage.
-     *
-     * <p>Rewrites it if a record with this ID already exists in the storage.
-     *
-     * @param id an ID of the record
-     * @param record a record to store
-     */
-    protected abstract void writeInternal(I id, EntityStorageRecord record);
-}
diff --git a/server/src/main/java/org/spine3/server/storage/EventStorage.java b/server/src/main/java/org/spine3/server/storage/EventStorage.java
index 61ce76ff531..b7a06b1536a 100644
--- a/server/src/main/java/org/spine3/server/storage/EventStorage.java
+++ b/server/src/main/java/org/spine3/server/storage/EventStorage.java
@@ -47,7 +47,7 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 import static org.spine3.base.Identifiers.idToString;
 import static org.spine3.protobuf.TypeUrl.ofEnclosed;
-import static org.spine3.validate.Validate.checkIsPositive;
+import static org.spine3.validate.Validate.checkPositive;
 import static org.spine3.validate.Validate.checkNotEmptyOrBlank;
 import static org.spine3.validate.Validate.checkValid;
 
@@ -80,7 +80,7 @@ public void write(EventId id, Event event) {
         checkNotNull(event);
 
         final EventStorageRecord record = toEventStorageRecord(id, event);
-        writeInternal(record);
+        writeRecord(record);
     }
 
     @Override
@@ -88,7 +88,7 @@ public Event read(EventId id) {
         checkNotClosed();
         checkNotNull(id);
 
-        final EventStorageRecord record = readInternal(id);
+        final EventStorageRecord record = readRecord(id);
         if (record == null) {
             return Event.getDefaultInstance();
         }
@@ -109,7 +109,7 @@ public Event read(EventId id) {
      *
      * @param record the record to write
      */
-    protected abstract void writeInternal(EventStorageRecord record);
+    protected abstract void writeRecord(EventStorageRecord record);
 
     /**
      * Reads storage format record.
@@ -118,7 +118,7 @@ public Event read(EventId id) {
      * @return the record instance of null if there's not record with such ID
      */
     @Nullable
-    protected abstract EventStorageRecord readInternal(EventId eventId);
+    protected abstract EventStorageRecord readRecord(EventId eventId);
 
     /** Converts EventStorageRecord to Event. */
     protected static Event toEvent(EventStorageRecord record) {
@@ -154,7 +154,7 @@ protected static Iterator<Event> toEventIterator(Iterator<EventStorageRecord> re
         checkNotEmptyOrBlank(eventType, "event type");
         final String producerId = idToString(Events.getProducer(context));
         checkNotEmptyOrBlank(producerId, "producer ID");
-        final Timestamp timestamp = checkIsPositive(context.getTimestamp(), "event time");
+        final Timestamp timestamp = checkPositive(context.getTimestamp(), "event time");
         final EventStorageRecord.Builder builder = EventStorageRecord.newBuilder()
                 .setTimestamp(timestamp)
                 .setEventType(eventType)
@@ -234,13 +234,13 @@ private static class MatchFilter implements Predicate<Event> {
 
         private MatchFilter(EventFilter filter) {
             final String eventType = filter.getEventType();
-            this.eventTypeUrl = eventType.isEmpty() ?
-                                null :
-                                TypeUrl.of(eventType);
+            this.eventTypeUrl = eventType.isEmpty()
+                                ? null
+                                : TypeUrl.of(eventType);
             final List<Any> aggregateIdList = filter.getAggregateIdList();
-            this.aggregateIds = aggregateIdList.isEmpty() ?
-                                null :
-                                aggregateIdList;
+            this.aggregateIds = aggregateIdList.isEmpty()
+                                ? null
+                                : aggregateIdList;
         }
 
         @Override
diff --git a/server/src/main/java/org/spine3/server/storage/ProjectionStorage.java b/server/src/main/java/org/spine3/server/storage/ProjectionStorage.java
index 87971fbdfd2..952dd38c236 100644
--- a/server/src/main/java/org/spine3/server/storage/ProjectionStorage.java
+++ b/server/src/main/java/org/spine3/server/storage/ProjectionStorage.java
@@ -36,26 +36,24 @@
  * @author Alexander Litus
  */
 @SPI
-public abstract class ProjectionStorage<I> extends AbstractStorage<I, EntityStorageRecord> {
+public abstract class ProjectionStorage<I> extends RecordStorage<I> {
 
     public ProjectionStorage(boolean multitenant) {
         super(multitenant);
     }
 
+    @Nullable
     @Override
-    public EntityStorageRecord read(I id) {
-        checkNotClosed();
-
-        final EntityStorage<I> storage = getEntityStorage();
+    protected EntityStorageRecord readRecord(I id) {
+        final RecordStorage<I> storage = getRecordStorage();
         final EntityStorageRecord record = storage.read(id);
         return record;
     }
 
-    @Override
-    public void write(I id, EntityStorageRecord record) {
-        checkNotClosed();
 
-        final EntityStorage<I> storage = getEntityStorage();
+    @Override
+    protected void writeRecord(I id, EntityStorageRecord record) {
+        final RecordStorage<I> storage = getRecordStorage();
         storage.write(id, record);
     }
 
@@ -75,5 +73,5 @@ public void write(I id, EntityStorageRecord record) {
     public abstract Timestamp readLastHandledEventTime();
 
     /** Returns an entity storage implementation. */
-    public abstract EntityStorage<I> getEntityStorage();
+    public abstract RecordStorage<I> getRecordStorage();
 }
diff --git a/server/src/main/java/org/spine3/server/storage/RecordStorage.java b/server/src/main/java/org/spine3/server/storage/RecordStorage.java
new file mode 100644
index 00000000000..c274d6bd744
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/storage/RecordStorage.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.storage;
+
+import com.google.protobuf.Any;
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.Message;
+import org.spine3.SPI;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.entity.Entity;
+import org.spine3.server.entity.FieldMasks;
+
+import javax.annotation.Nullable;
+import java.util.Map;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * A storage keeping messages with identity.
+ *
+ * @param <I> the type of entity IDs
+ * @author Alexander Yevsyukov
+ * @see Entity
+ */
+@SPI
+public abstract class RecordStorage<I> extends AbstractStorage<I, EntityStorageRecord>
+        implements BulkStorageOperationsMixin<I, EntityStorageRecord> {
+
+    protected RecordStorage(boolean multitenant) {
+        super(multitenant);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public EntityStorageRecord read(I id) {
+        checkNotClosed();
+        checkNotNull(id);
+
+        final EntityStorageRecord record = readRecord(checkNotNull(id));
+        if (record == null) {
+            return EntityStorageRecord.getDefaultInstance();
+        }
+        return record;
+    }
+
+    /**
+     * Reads a single item from the storage and applies a {@link FieldMask} to it.
+     *
+     * @param id        ID of the item to read.
+     * @param fieldMask fields to read.
+     * @return the item with the given ID and with the {@code FieldMask} applied.
+     * @see #read(Object)
+     */
+    public EntityStorageRecord read(I id, FieldMask fieldMask) {
+        final EntityStorageRecord rawResult = read(id);
+
+        final EntityStorageRecord.Builder builder = EntityStorageRecord.newBuilder(rawResult);
+        final Any state = builder.getState();
+        final TypeUrl type = TypeUrl.of(state.getTypeUrl());
+        final Message stateAsMessage = AnyPacker.unpack(state);
+
+        final Message maskedState = FieldMasks.applyMask(fieldMask, stateAsMessage, type);
+
+        final Any packedState = AnyPacker.pack(maskedState);
+        builder.setState(packedState);
+        return builder.build();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void write(I id, EntityStorageRecord record) {
+        checkNotNull(id);
+        checkArgument(record.hasState(), "Record does not have state field.");
+        checkNotClosed();
+
+        writeRecord(id, record);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Iterable<EntityStorageRecord> readMultiple(Iterable<I> ids) {
+        checkNotClosed();
+        checkNotNull(ids);
+
+        return readMultipleRecords(ids);
+    }
+
+    /**
+     * Reads multiple items from the storage and apply {@link FieldMask} to each of the results.
+     *
+     * @param ids       the IDs of the items to read
+     * @param fieldMask the mask to apply
+     * @return the items with the given IDs and with the given {@code FieldMask} applied
+     */
+    public Iterable<EntityStorageRecord> readMultiple(Iterable<I> ids, FieldMask fieldMask) {
+        checkNotClosed();
+        checkNotNull(ids);
+
+        return readMultipleRecords(ids, fieldMask);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Map<I, EntityStorageRecord> readAll() {
+        checkNotClosed();
+
+        return readAllRecords();
+    }
+
+    /**
+     * Reads all items from the storage and apply {@link FieldMask} to each of the results.
+     *
+     * @param fieldMask the {@code FieldMask} to apply
+     * @return all items from this repository with the given {@code FieldMask} applied
+     */
+    public Map<I, EntityStorageRecord> readAll(FieldMask fieldMask) {
+        checkNotClosed();
+
+        return readAllRecords(fieldMask);
+    }
+
+    //
+    // Internal storage methods
+    //---------------------------
+
+    /**
+     * Reads a record from the storage by the passed ID.
+     *
+     * @param id the ID of the record to load
+     * @return a record instance or {@code null} if there is no record with this ID
+     */
+    @Nullable
+    protected abstract EntityStorageRecord readRecord(I id);
+
+    /** @see BulkStorageOperationsMixin#readMultiple(java.lang.Iterable) */
+    protected abstract Iterable<EntityStorageRecord> readMultipleRecords(Iterable<I> ids);
+
+    /** @see BulkStorageOperationsMixin#readMultiple(java.lang.Iterable) */
+    protected abstract Iterable<EntityStorageRecord> readMultipleRecords(Iterable<I> ids, FieldMask fieldMask);
+
+    /** @see BulkStorageOperationsMixin#readAll() */
+    protected abstract Map<I, EntityStorageRecord> readAllRecords();
+
+    /** @see BulkStorageOperationsMixin#readAll() */
+    protected abstract Map<I, EntityStorageRecord> readAllRecords(FieldMask fieldMask);
+
+    /**
+     * Writes a record into the storage.
+     *
+     * <p>Rewrites it if a record with this ID already exists in the storage.
+     *
+     * @param id     an ID of the record
+     * @param record a record to store
+     */
+    protected abstract void writeRecord(I id, EntityStorageRecord record);
+}
diff --git a/server/src/main/java/org/spine3/server/storage/StandStorage.java b/server/src/main/java/org/spine3/server/storage/StandStorage.java
new file mode 100644
index 00000000000..ff384fb1314
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/storage/StandStorage.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.storage;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.protobuf.Any;
+import com.google.protobuf.FieldMask;
+import org.spine3.SPI;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.stand.AggregateStateId;
+import org.spine3.server.stand.Stand;
+
+/**
+ * Serves as a storage for the latest {@link org.spine3.server.aggregate.Aggregate} states.
+ *
+ * <p>Used by an instance of {@link Stand} to optimize the {@code Aggregate} state fetch performance.
+ *
+ * @author Alex Tymchenko
+ * @see Any#getTypeUrl()
+ * @see Stand
+ */
+@SPI
+public abstract class StandStorage extends RecordStorage<AggregateStateId> {
+
+    protected StandStorage(boolean multitenant) {
+        super(multitenant);
+    }
+
+    /**
+     * Reads all the state records by the given type.
+     *
+     * @param type a {@link TypeUrl} instance
+     * @return the state records which {@link Any#getTypeUrl()} equals the argument value
+     */
+    public abstract ImmutableCollection<EntityStorageRecord> readAllByType(TypeUrl type);
+
+    /**
+     * Reads all the state records by the given type.
+     *
+     * @param type a {@link TypeUrl} instance
+     * @return the state records which {@link Any#getTypeUrl()} equals the argument value
+     */
+    public abstract ImmutableCollection<EntityStorageRecord> readAllByType(TypeUrl type, FieldMask fieldMask);
+}
diff --git a/server/src/main/java/org/spine3/server/storage/StorageFactory.java b/server/src/main/java/org/spine3/server/storage/StorageFactory.java
index 9c0385b6dff..52d2520c5b4 100644
--- a/server/src/main/java/org/spine3/server/storage/StorageFactory.java
+++ b/server/src/main/java/org/spine3/server/storage/StorageFactory.java
@@ -45,6 +45,9 @@ public interface StorageFactory extends AutoCloseable {
     /** Creates a new {@link EventStorage} instance. */
     EventStorage createEventStorage();
 
+    /** Creates a new {@link StandStorage} instance. */
+    StandStorage createStandStorage();
+
     /**
      * Creates a new {@link AggregateStorage} instance.
      *
@@ -54,12 +57,12 @@ public interface StorageFactory extends AutoCloseable {
     <I> AggregateStorage<I> createAggregateStorage(Class<? extends Aggregate<I, ?, ?>> aggregateClass);
 
     /**
-     * Creates a new {@link EntityStorage} instance.
+     * Creates a new {@link RecordStorage} instance.
      *
      * @param <I>         the type of entity IDs
      * @param entityClass the class of entities to store
      */
-    <I> EntityStorage<I> createEntityStorage(Class<? extends Entity<I, ?>> entityClass);
+    <I> RecordStorage<I> createRecordStorage(Class<? extends Entity<I, ?>> entityClass);
 
     /**
      * Creates a new {@link ProjectionStorage} instance.
@@ -68,4 +71,5 @@ public interface StorageFactory extends AutoCloseable {
      * @param <I>             the type of stream projection IDs
      */
     <I> ProjectionStorage<I> createProjectionStorage(Class<? extends Entity<I, ?>> projectionClass);
+
 }
diff --git a/server/src/main/java/org/spine3/server/storage/memory/InMemoryAggregateStorage.java b/server/src/main/java/org/spine3/server/storage/memory/InMemoryAggregateStorage.java
index 8a8a139af26..72236b8b8dd 100644
--- a/server/src/main/java/org/spine3/server/storage/memory/InMemoryAggregateStorage.java
+++ b/server/src/main/java/org/spine3/server/storage/memory/InMemoryAggregateStorage.java
@@ -60,7 +60,7 @@ protected static <I> InMemoryAggregateStorage<I> newInstance() {
     }
 
     @Override
-    protected void writeInternal(I id, AggregateStorageRecord record) {
+    protected void writeRecord(I id, AggregateStorageRecord record) {
         recordMap.put(id, record);
     }
 
diff --git a/server/src/main/java/org/spine3/server/storage/memory/InMemoryEntityStorage.java b/server/src/main/java/org/spine3/server/storage/memory/InMemoryEntityStorage.java
deleted file mode 100644
index 4391ffbcd40..00000000000
--- a/server/src/main/java/org/spine3/server/storage/memory/InMemoryEntityStorage.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright 2016, TeamDev Ltd. All rights reserved.
- *
- * Redistribution and use in source and/or binary forms, with or without
- * modification, must retain the above copyright notice and the following
- * disclaimer.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package org.spine3.server.storage.memory;
-
-import org.spine3.server.storage.EntityStorage;
-import org.spine3.server.storage.EntityStorageRecord;
-import org.spine3.server.users.CurrentTenant;
-import org.spine3.users.TenantId;
-
-import java.util.Map;
-
-import static com.google.common.base.Preconditions.checkState;
-import static com.google.common.collect.Maps.newHashMap;
-
-/**
- * Memory-based implementation of {@link EntityStorage}.
- *
- * @author Alexander Litus
- */
-/* package */ class InMemoryEntityStorage<I> extends EntityStorage<I> {
-
-    /** A stub instance of {@code TenantId} to be used by the storage in single-tenant context. */
-    private static final TenantId singleTenant = TenantId.newBuilder().setValue("SINGLE_TENANT").build();
-
-    private final Map<TenantId, Map<I, EntityStorageRecord>> tenantToStorageMap = newHashMap();
-
-    protected InMemoryEntityStorage(boolean multitenant) {
-        super(multitenant);
-    }
-
-    protected static <I> InMemoryEntityStorage<I> newInstance(boolean multitenant) {
-        return new InMemoryEntityStorage<>(multitenant);
-    }
-
-    private Map<I, EntityStorageRecord> getStorage() {
-        final TenantId tenantId = isMultitenant() ? CurrentTenant.get() : singleTenant;
-        checkState(tenantId != null, "Current tenant is null");
-
-        Map<I, EntityStorageRecord> storage = tenantToStorageMap.get(tenantId);
-        if (storage == null) {
-            storage = newHashMap();
-            tenantToStorageMap.put(tenantId, storage);
-        }
-        return storage;
-    }
-
-    @Override
-    protected EntityStorageRecord readInternal(I id) {
-        return getStorage().get(id);
-    }
-
-    @Override
-    protected void writeInternal(I id, EntityStorageRecord record) {
-        getStorage().put(id, record);
-    }
-
-    @Override
-    public void close() throws Exception {
-        super.close();
-    }
-}
diff --git a/server/src/main/java/org/spine3/server/storage/memory/InMemoryEventStorage.java b/server/src/main/java/org/spine3/server/storage/memory/InMemoryEventStorage.java
index c60d4a6e905..461679f66cc 100644
--- a/server/src/main/java/org/spine3/server/storage/memory/InMemoryEventStorage.java
+++ b/server/src/main/java/org/spine3/server/storage/memory/InMemoryEventStorage.java
@@ -82,7 +82,7 @@ public Iterator<Event> iterator(EventStreamQuery query) {
     }
 
     @Override
-    protected void writeInternal(EventStorageRecord record) {
+    protected void writeRecord(EventStorageRecord record) {
         checkNotNull(record);
         final String eventId = record.getEventId();
         checkState(!eventId.isEmpty(), "eventId cannot be empty");
@@ -92,7 +92,7 @@ protected void writeInternal(EventStorageRecord record) {
 
     @Nullable
     @Override
-    protected EventStorageRecord readInternal(EventId eventId) {
+    protected EventStorageRecord readRecord(EventId eventId) {
         final EventStorageRecord result = index.get(eventId.getUuid());
         return result;
     }
diff --git a/server/src/main/java/org/spine3/server/storage/memory/InMemoryProjectionStorage.java b/server/src/main/java/org/spine3/server/storage/memory/InMemoryProjectionStorage.java
index 4edf653c214..b83b09e9355 100644
--- a/server/src/main/java/org/spine3/server/storage/memory/InMemoryProjectionStorage.java
+++ b/server/src/main/java/org/spine3/server/storage/memory/InMemoryProjectionStorage.java
@@ -20,9 +20,13 @@
 
 package org.spine3.server.storage.memory;
 
+import com.google.protobuf.FieldMask;
 import com.google.protobuf.Timestamp;
-import org.spine3.server.storage.EntityStorage;
+import org.spine3.server.storage.EntityStorageRecord;
 import org.spine3.server.storage.ProjectionStorage;
+import org.spine3.server.storage.RecordStorage;
+
+import java.util.Map;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -34,18 +38,18 @@
  */
 /* package */ class InMemoryProjectionStorage<I> extends ProjectionStorage<I> {
 
-    private final InMemoryEntityStorage<I> entityStorage;
+    private final InMemoryRecordStorage<I> recordStorage;
 
     /** The time of the last handled event. */
     private Timestamp timestampOfLastEvent;
 
-    public static <I> InMemoryProjectionStorage<I> newInstance(InMemoryEntityStorage<I> entityStorage, boolean multitenant) {
+    public static <I> InMemoryProjectionStorage<I> newInstance(InMemoryRecordStorage<I> entityStorage, boolean multitenant) {
         return new InMemoryProjectionStorage<>(entityStorage, multitenant);
     }
 
-    private InMemoryProjectionStorage(InMemoryEntityStorage<I> entityStorage, boolean multitenant) {
+    private InMemoryProjectionStorage(InMemoryRecordStorage<I> recordStorage, boolean multitenant) {
         super(multitenant);
-        this.entityStorage = entityStorage;
+        this.recordStorage = recordStorage;
     }
 
     @Override
@@ -60,13 +64,36 @@ public Timestamp readLastHandledEventTime() {
     }
 
     @Override
-    public EntityStorage<I> getEntityStorage() {
-        return entityStorage;
+    public RecordStorage<I> getRecordStorage() {
+        return recordStorage;
     }
 
     @Override
     public void close() throws Exception {
-        entityStorage.close();
+        recordStorage.close();
         super.close();
     }
+
+    @Override
+    protected Iterable<EntityStorageRecord> readMultipleRecords(Iterable<I> ids) {
+        final Iterable<EntityStorageRecord> result = recordStorage.readMultiple(ids);
+        return result;
+    }
+
+    @Override
+    protected Iterable<EntityStorageRecord> readMultipleRecords(Iterable<I> ids, FieldMask fieldMask) {
+        return recordStorage.readMultiple(ids, fieldMask);
+    }
+
+    @Override
+    protected Map<I, EntityStorageRecord> readAllRecords() {
+        final Map<I, EntityStorageRecord> result = recordStorage.readAll();
+        return result;
+    }
+
+    @Override
+    protected Map<I, EntityStorageRecord> readAllRecords(FieldMask fieldMask) {
+        final Map<I, EntityStorageRecord> result = recordStorage.readAll(fieldMask);
+        return result;
+    }
 }
diff --git a/server/src/main/java/org/spine3/server/storage/memory/InMemoryRecordStorage.java b/server/src/main/java/org/spine3/server/storage/memory/InMemoryRecordStorage.java
new file mode 100644
index 00000000000..91ad9240b22
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/storage/memory/InMemoryRecordStorage.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.storage.memory;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Any;
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.Message;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.entity.FieldMasks;
+import org.spine3.server.storage.EntityStorageRecord;
+import org.spine3.server.storage.RecordStorage;
+import org.spine3.server.users.CurrentTenant;
+import org.spine3.users.TenantId;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.Map;
+
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.collect.Maps.newHashMap;
+
+/**
+ * Memory-based implementation of {@link RecordStorage}.
+ *
+ * @author Alexander Litus, Alex Tymchenko
+ */
+/* package */ class InMemoryRecordStorage<I> extends RecordStorage<I> {
+
+    /** A stub instance of {@code TenantId} to be used by the storage in single-tenant context. */
+    private static final TenantId singleTenant = TenantId.newBuilder()
+                                                         .setValue("SINGLE_TENANT")
+                                                         .build();
+
+    private final Map<TenantId, Map<I, EntityStorageRecord>> tenantToStorageMap = newHashMap();
+
+    protected InMemoryRecordStorage(boolean multitenant) {
+        super(multitenant);
+    }
+
+    @Override
+    protected Iterable<EntityStorageRecord> readMultipleRecords(final Iterable<I> givenIds, FieldMask fieldMask) {
+        final Map<I, EntityStorageRecord> storage = getStorage();
+
+        // It is not possible to return an immutable collection, since {@code null} may be present in it.
+        final Collection<EntityStorageRecord> result = new LinkedList<>();
+
+        for (I givenId : givenIds) {
+            final EntityStorageRecord matchingResult = findAndApplyFieldMask(storage, givenId, fieldMask);
+            result.add(matchingResult);
+        }
+        return result;
+    }
+
+    private EntityStorageRecord findAndApplyFieldMask(Map<I, EntityStorageRecord> storage,
+                                                      I givenId,
+                                                      FieldMask fieldMask) {
+        EntityStorageRecord matchingResult = null;
+        for (I recordId : storage.keySet()) {
+            if (recordId.equals(givenId)) {
+                EntityStorageRecord.Builder matchingRecord = storage.get(recordId)
+                                                                    .toBuilder();
+                final Any state = matchingRecord.getState();
+                final TypeUrl typeUrl = TypeUrl.of(state.getTypeUrl());
+                final Message wholeState = AnyPacker.unpack(state);
+                final Message maskedState = FieldMasks.applyMask(fieldMask, wholeState, typeUrl);
+                final Any processed = AnyPacker.pack(maskedState);
+
+                matchingRecord.setState(processed);
+                matchingResult = matchingRecord.build();
+            }
+        }
+        return matchingResult;
+    }
+
+    @Override
+    protected Iterable<EntityStorageRecord> readMultipleRecords(Iterable<I> ids) {
+        return readMultipleRecords(ids, FieldMask.getDefaultInstance());
+    }
+
+    @Override
+    protected Map<I, EntityStorageRecord> readAllRecords() {
+        final Map<I, EntityStorageRecord> storage = getStorage();
+
+        final ImmutableMap<I, EntityStorageRecord> result = ImmutableMap.copyOf(storage);
+        return result;
+    }
+
+    @Override
+    protected Map<I, EntityStorageRecord> readAllRecords(FieldMask fieldMask) {
+        if (fieldMask.getPathsList()
+                     .isEmpty()) {
+            return readAllRecords();
+        }
+
+        final Map<I, EntityStorageRecord> storage = getStorage();
+
+        if (storage.isEmpty()) {
+            return ImmutableMap.of();
+        }
+
+        final ImmutableMap.Builder<I, EntityStorageRecord> result = ImmutableMap.builder();
+
+        for (Map.Entry<I, EntityStorageRecord> storageEntry : storage.entrySet()) {
+            final I id = storageEntry.getKey();
+            final EntityStorageRecord rawRecord = storageEntry.getValue();
+            final TypeUrl type = TypeUrl.of(rawRecord.getState()
+                                                     .getTypeUrl());
+            final Any recordState = rawRecord.getState();
+            final Message stateAsMessage = AnyPacker.unpack(recordState);
+            final Message processedState = FieldMasks.applyMask(fieldMask, stateAsMessage, type);
+            final Any packedState = AnyPacker.pack(processedState);
+            final EntityStorageRecord resultingRecord = EntityStorageRecord.newBuilder()
+                                                                           .setState(packedState)
+                                                                           .build();
+            result.put(id, resultingRecord);
+        }
+
+        return result.build();
+    }
+
+    protected static <I> InMemoryRecordStorage<I> newInstance(boolean multitenant) {
+        return new InMemoryRecordStorage<>(multitenant);
+    }
+
+    private Map<I, EntityStorageRecord> getStorage() {
+        final TenantId tenantId = isMultitenant() ? CurrentTenant.get() : singleTenant;
+        checkState(tenantId != null, "Current tenant is null");
+
+        Map<I, EntityStorageRecord> storage = tenantToStorageMap.get(tenantId);
+        if (storage == null) {
+            storage = newHashMap();
+            tenantToStorageMap.put(tenantId, storage);
+        }
+        return storage;
+    }
+
+    @Override
+    protected EntityStorageRecord readRecord(I id) {
+        return getStorage().get(id);
+    }
+
+    @Override
+    protected void writeRecord(I id, EntityStorageRecord record) {
+        getStorage().put(id, record);
+    }
+
+    @Override
+    public void close() throws Exception {
+        super.close();
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/storage/memory/InMemoryStandStorage.java b/server/src/main/java/org/spine3/server/storage/memory/InMemoryStandStorage.java
new file mode 100644
index 00000000000..1bb8182bb97
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/storage/memory/InMemoryStandStorage.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.storage.memory;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Maps;
+import com.google.protobuf.FieldMask;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.stand.AggregateStateId;
+import org.spine3.server.storage.EntityStorageRecord;
+import org.spine3.server.storage.StandStorage;
+
+import javax.annotation.Nullable;
+import java.util.Map;
+import java.util.concurrent.ConcurrentMap;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+/**
+ * In-memory implementation of {@link StandStorage}.
+ *
+ * <p>Uses a {@link ConcurrentMap} for internal storage.
+ *
+ * @author Alex Tymchenko
+ */
+public class InMemoryStandStorage extends StandStorage {
+
+    private final InMemoryRecordStorage<AggregateStateId> recordStorage;
+
+    private InMemoryStandStorage(Builder builder) {
+        super(builder.isMultitenant());
+        recordStorage = new InMemoryRecordStorage<>(builder.isMultitenant());
+    }
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    @Override
+    public ImmutableCollection<EntityStorageRecord> readAllByType(final TypeUrl type) {
+        return readAllByType(type, FieldMask.getDefaultInstance());
+    }
+
+    @Override
+    public ImmutableCollection<EntityStorageRecord> readAllByType(final TypeUrl type, FieldMask fieldMask) {
+        final Map<AggregateStateId, EntityStorageRecord> allRecords = readAll(fieldMask);
+        final Map<AggregateStateId, EntityStorageRecord> resultMap = Maps.filterKeys(allRecords, new Predicate<AggregateStateId>() {
+            @Override
+            public boolean apply(@Nullable AggregateStateId stateId) {
+                checkNotNull(stateId);
+                final boolean typeMatches = stateId.getStateType()
+                                                   .equals(type);
+                return typeMatches;
+            }
+        });
+
+        final ImmutableList<EntityStorageRecord> result = ImmutableList.copyOf(resultMap.values());
+        return result;
+    }
+
+    @Nullable
+    @Override
+    protected EntityStorageRecord readRecord(AggregateStateId id) {
+        final EntityStorageRecord result = recordStorage.read(id);
+        return result;
+    }
+
+    @Override
+    protected Iterable<EntityStorageRecord> readMultipleRecords(Iterable<AggregateStateId> ids) {
+        final Iterable<EntityStorageRecord> result = recordStorage.readMultiple(ids);
+        return result;
+    }
+
+    @Override
+    protected Iterable<EntityStorageRecord> readMultipleRecords(Iterable<AggregateStateId> ids, FieldMask fieldMask) {
+        final Iterable<EntityStorageRecord> result = recordStorage.readMultiple(ids, fieldMask);
+        return result;
+    }
+
+    @Override
+    protected Map<AggregateStateId, EntityStorageRecord> readAllRecords() {
+        final Map<AggregateStateId, EntityStorageRecord> result = recordStorage.readAll();
+        return result;
+    }
+
+    @Override
+    protected Map<AggregateStateId, EntityStorageRecord> readAllRecords(FieldMask fieldMask) {
+        final Map<AggregateStateId, EntityStorageRecord> result = recordStorage.readAll(fieldMask);
+        return result;
+    }
+
+    @Override
+    protected void writeRecord(AggregateStateId id, EntityStorageRecord record) {
+        final TypeUrl recordType = TypeUrl.of(record.getState()
+                                                    .getTypeUrl());
+        checkState(id.getStateType().equals(recordType), "The typeUrl of the record does not correspond to id");
+
+        recordStorage.write(id, record);
+    }
+
+
+    public static class Builder {
+
+        private boolean multitenant;
+
+        public boolean isMultitenant() {
+            return multitenant;
+        }
+
+        public Builder setMultitenant(boolean multitenant) {
+            this.multitenant = multitenant;
+            return this;
+        }
+
+        /**
+         * Builds an instance of in-memory stand storage.
+         *
+         * @return an instance of in-memory storage
+         */
+        public InMemoryStandStorage build() {
+            final InMemoryStandStorage result = new InMemoryStandStorage(this);
+            return result;
+        }
+
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/storage/memory/InMemoryStorageFactory.java b/server/src/main/java/org/spine3/server/storage/memory/InMemoryStorageFactory.java
index 6f5fc9884ff..98e14aa2321 100644
--- a/server/src/main/java/org/spine3/server/storage/memory/InMemoryStorageFactory.java
+++ b/server/src/main/java/org/spine3/server/storage/memory/InMemoryStorageFactory.java
@@ -24,9 +24,10 @@
 import org.spine3.server.entity.Entity;
 import org.spine3.server.storage.AggregateStorage;
 import org.spine3.server.storage.CommandStorage;
-import org.spine3.server.storage.EntityStorage;
+import org.spine3.server.storage.RecordStorage;
 import org.spine3.server.storage.EventStorage;
 import org.spine3.server.storage.ProjectionStorage;
+import org.spine3.server.storage.StandStorage;
 import org.spine3.server.storage.StorageFactory;
 
 /**
@@ -57,6 +58,14 @@ public EventStorage createEventStorage() {
         return new InMemoryEventStorage(isMultitenant());
     }
 
+    @Override
+    public StandStorage createStandStorage() {
+        final InMemoryStandStorage result = InMemoryStandStorage.newBuilder()
+                                                                .setMultitenant(isMultitenant())
+                                                                .build();
+        return result;
+    }
+
     /** NOTE: the parameter is unused. */
     @Override
     public <I> AggregateStorage<I> createAggregateStorage(Class<? extends Aggregate<I, ?, ?>> unused) {
@@ -69,14 +78,14 @@ public <I> AggregateStorage<I> createAggregateStorage(Class<? extends Aggregate<
      * NOTE: the parameter is unused.
      */
     @Override
-    public <I> EntityStorage<I> createEntityStorage(Class<? extends Entity<I, ?>> unused) {
-        return InMemoryEntityStorage.newInstance(isMultitenant());
+    public <I> RecordStorage<I> createRecordStorage(Class<? extends Entity<I, ?>> unused) {
+        return InMemoryRecordStorage.newInstance(isMultitenant());
     }
 
     @Override
     public <I> ProjectionStorage<I> createProjectionStorage(Class<? extends Entity<I, ?>> unused) {
         final boolean multitenant = isMultitenant();
-        final InMemoryEntityStorage<I> entityStorage = InMemoryEntityStorage.newInstance(multitenant);
+        final InMemoryRecordStorage<I> entityStorage = InMemoryRecordStorage.newInstance(multitenant);
         return InMemoryProjectionStorage.newInstance(entityStorage, multitenant);
     }
 
diff --git a/server/src/main/java/org/spine3/server/transport/GrpcContainer.java b/server/src/main/java/org/spine3/server/transport/GrpcContainer.java
new file mode 100644
index 00000000000..274c312b4da
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/transport/GrpcContainer.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.transport;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import io.grpc.BindableService;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerServiceDefinition;
+import org.spine3.client.ConnectionConstants;
+
+import javax.annotation.Nullable;
+import java.io.IOException;
+import java.util.Set;
+
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Throwables.propagate;
+
+/**
+ * Wrapping container for gRPC server.
+ *
+ * <p>Maintains and deploys several of gRPC services within a single server.
+ *
+ * <p>Uses {@link ServerServiceDefinition}s of each service.
+ *
+ * @author Alex Tymchenko
+ */
+public class GrpcContainer {
+
+    private static final String SERVER_NOT_STARTED_MSG = "gRPC server was not started or is shut down already.";
+
+    private final int port;
+    private final ImmutableSet<ServerServiceDefinition> services;
+
+    @Nullable
+    private io.grpc.Server grpcServer;
+
+    public static Builder newBuilder() {
+        return new Builder();
+    }
+
+    protected GrpcContainer(Builder builder) {
+        this.port = builder.getPort();
+        this.services = builder.getServices();
+    }
+
+    /**
+     * Starts the service.
+     *
+     * @throws IOException if unable to bind
+     */
+    public void start() throws IOException {
+        checkState(grpcServer == null, "gRPC server is started already.");
+        grpcServer = createGrpcServer();
+        grpcServer.start();
+    }
+
+    /**
+     * Returns {@code true} if the server is shut down or was not started at all, {@code false} otherwise.
+     *
+     * @see GrpcContainer#shutdown()
+     */
+    public boolean isShutdown() {
+        final boolean isShutdown = grpcServer == null;
+        return isShutdown;
+    }
+
+    /** Initiates an orderly shutdown in which existing calls continue but new calls are rejected. */
+    public void shutdown() {
+        checkState(grpcServer != null, SERVER_NOT_STARTED_MSG);
+        grpcServer.shutdown();
+        grpcServer = null;
+    }
+
+    /** Waits for the service to become terminated. */
+    public void awaitTermination() {
+        checkState(grpcServer != null, SERVER_NOT_STARTED_MSG);
+        try {
+            grpcServer.awaitTermination();
+        } catch (InterruptedException e) {
+            throw propagate(e);
+        }
+    }
+
+    /**
+     * Check if the given gRPC service is scheduled for the deployment in this container.
+     *
+     * <p>Note, that the given gRPC service will become available to the clients, once the gRPC container is started.
+     * <p>To find out, whether the service is already available for calls, use {@link #isLive(BindableService)} method.
+     *
+     * @param service the gRPC service to check
+     * @return {@code true}, if the given gRPC service for deployment; {@code false} otherwise
+     */
+    public boolean isScheduledForDeployment(BindableService service) {
+        final String nameOfInterest = service.bindService()
+                                             .getServiceDescriptor()
+                                             .getName();
+        boolean serviceIsPresent = false;
+        for (ServerServiceDefinition serverServiceDefinition : services) {
+            final String scheduledServiceName = serverServiceDefinition.getServiceDescriptor()
+                                                                       .getName();
+            serviceIsPresent = serviceIsPresent || scheduledServiceName.equals(nameOfInterest);
+        }
+        return serviceIsPresent;
+    }
+
+    /**
+     * Check if the given gRPC service has actually been deployed and is available for interaction within this container.
+     *
+     * <p>Returns {@code true} if and only if
+     * <p>  a. the service has been previously scheduled for the deployment,
+     * <p>  b. the container has been started.
+     *
+     * @param service the gRPC service
+     * @return {@code true}, if the service is available for interaction within this container; {@code false} otherwise
+     */
+    public boolean isLive(BindableService service) {
+        final boolean inShutdownState = isShutdown();
+        final boolean scheduledForDeployment = isScheduledForDeployment(service);
+        final boolean result = !inShutdownState && scheduledForDeployment;
+        return result;
+    }
+
+    /**
+     * Makes the JVM shut down the service when it is shutting down itself.
+     *
+     * <p>Call this method when running the service in a separate JVM.
+     */
+    public void addShutdownHook() {
+        Runtime.getRuntime()
+               .addShutdownHook(new Thread(getOnShutdownCallback()));
+    }
+
+    @VisibleForTesting
+    /* package */ Server createGrpcServer() {
+        final ServerBuilder builder = ServerBuilder.forPort(port);
+        for (ServerServiceDefinition service : services) {
+            builder.addService(service);
+        }
+
+        return builder.build();
+    }
+
+    @VisibleForTesting
+    /* package */ Runnable getOnShutdownCallback() {
+        return new Runnable() {
+            // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+            @SuppressWarnings("UseOfSystemOutOrSystemErr")
+            @Override
+            public void run() {
+                final String serverClass = GrpcContainer.this.getClass()
+                                                             .getName();
+                try {
+                    if (!isShutdown()) {
+                        System.err.println("Shutting down " + serverClass + " since JVM is shutting down...");
+                        shutdown();
+                        System.err.println(serverClass + " shut down.");
+                    }
+                } catch (RuntimeException e) {
+                    e.printStackTrace(System.err);
+                }
+            }
+        };
+    }
+
+    public static class Builder {
+
+        private int port = ConnectionConstants.DEFAULT_CLIENT_SERVICE_PORT;
+        private final Set<ServerServiceDefinition> serviceDefinitions = Sets.newHashSet();
+
+        public Builder setPort(int port) {
+            this.port = port;
+            return this;
+        }
+
+        public int getPort() {
+            return this.port;
+        }
+
+        public Builder addService(BindableService service) {
+            serviceDefinitions.add(service.bindService());
+            return this;
+        }
+
+        public Builder removeService(ServerServiceDefinition service) {
+            serviceDefinitions.remove(service);
+            return this;
+        }
+
+        public ImmutableSet<ServerServiceDefinition> getServices() {
+            return ImmutableSet.copyOf(serviceDefinitions);
+        }
+
+        public GrpcContainer build() {
+            return new GrpcContainer(this);
+        }
+    }
+}
diff --git a/server/src/main/java/org/spine3/server/transport/package-info.java b/server/src/main/java/org/spine3/server/transport/package-info.java
new file mode 100644
index 00000000000..7d4da5aeb98
--- /dev/null
+++ b/server/src/main/java/org/spine3/server/transport/package-info.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * This package contains classes and interfaces defining data transport options between Spine apps and the outer world.
+ *
+ * <p>Typical transport options include gRPC servers, Firebase adapters etc.
+ */
+@ParametersAreNonnullByDefault
+package org.spine3.server.transport;
+
+import javax.annotation.ParametersAreNonnullByDefault;
diff --git a/server/src/main/java/org/spine3/server/validate/MessageFieldValidator.java b/server/src/main/java/org/spine3/server/validate/MessageFieldValidator.java
index f7e8b2a0262..ee704de6874 100644
--- a/server/src/main/java/org/spine3/server/validate/MessageFieldValidator.java
+++ b/server/src/main/java/org/spine3/server/validate/MessageFieldValidator.java
@@ -132,9 +132,9 @@ private void validateTimestamps() {
      * @return {@code true} if the time is valid according to {@code whenExpected} parameter, {@code false} otherwise
      */
     private static boolean isTimeInvalid(Timestamp timeToCheck, Time whenExpected, Timestamp now) {
-        final boolean isValid = (whenExpected == FUTURE) ?
-                                isLaterThan(timeToCheck, /*than*/ now) :
-                                isLaterThan(now, /*than*/ timeToCheck);
+        final boolean isValid = (whenExpected == FUTURE)
+                                ? isLaterThan(timeToCheck, /*than*/ now)
+                                : isLaterThan(now, /*than*/ timeToCheck);
         final boolean isInvalid = !isValid;
         return isInvalid;
     }
diff --git a/server/src/main/java/org/spine3/server/validate/NumberFieldValidator.java b/server/src/main/java/org/spine3/server/validate/NumberFieldValidator.java
index b2981e82ce1..fafed65b1ac 100644
--- a/server/src/main/java/org/spine3/server/validate/NumberFieldValidator.java
+++ b/server/src/main/java/org/spine3/server/validate/NumberFieldValidator.java
@@ -131,9 +131,9 @@ private boolean notFitToDecimalMin(V value) {
         }
         final V min = toNumber(minAsString);
         final int comparisonResult = value.compareTo(min);
-        final boolean fits = isMinDecimalInclusive ?
-                             comparisonResult >= 0 :
-                             comparisonResult > 0;
+        final boolean fits = isMinDecimalInclusive
+                             ? comparisonResult >= 0
+                             : comparisonResult > 0;
         final boolean notFit = !fits;
         return notFit;
     }
@@ -144,9 +144,9 @@ private boolean notFitToDecimalMax(V value) {
             return false;
         }
         final V max = toNumber(maxAsString);
-        final boolean fits = isMaxDecimalInclusive ?
-                             value.compareTo(max) <= 0 :
-                             value.compareTo(max) < 0;
+        final boolean fits = isMaxDecimalInclusive
+                             ? value.compareTo(max) <= 0
+                             : value.compareTo(max) < 0;
         final boolean notFit = !fits;
         return notFit;
     }
diff --git a/server/src/main/proto/spine/server/storage/entity_storage.proto b/server/src/main/proto/spine/server/storage/record_storage.proto
similarity index 94%
rename from server/src/main/proto/spine/server/storage/entity_storage.proto
rename to server/src/main/proto/spine/server/storage/record_storage.proto
index 58602225be3..c463d5534e1 100644
--- a/server/src/main/proto/spine/server/storage/entity_storage.proto
+++ b/server/src/main/proto/spine/server/storage/record_storage.proto
@@ -25,7 +25,7 @@ option (type_url_prefix) = "type.spine3.org";
 option (SPI_all) = true;
 option java_generate_equals_and_hash = true;
 option java_multiple_files = true;
-option java_outer_classname = "EntityStorageProto";
+option java_outer_classname = "RecordStorageProto";
 option java_package = "org.spine3.server.storage";
 
 import "google/protobuf/timestamp.proto";
@@ -33,7 +33,7 @@ import "google/protobuf/any.proto";
 
 import "spine/annotations.proto";
 
-// Used to store entities in the entity storage.
+// Used to store entities in the record storage.
 message EntityStorageRecord {
     // The timestamp of the last entity modification.
     google.protobuf.Timestamp when_modified = 1;
diff --git a/server/src/test/java/org/spine3/server/ClientServiceShould.java b/server/src/test/java/org/spine3/server/ClientServiceShould.java
deleted file mode 100644
index dda8606ed25..00000000000
--- a/server/src/test/java/org/spine3/server/ClientServiceShould.java
+++ /dev/null
@@ -1,336 +0,0 @@
-/*
- * Copyright 2016, TeamDev Ltd. All rights reserved.
- *
- * Redistribution and use in source and/or binary forms, with or without
- * modification, must retain the above copyright notice and the following
- * disclaimer.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package org.spine3.server;
-
-
-import com.google.common.collect.Sets;
-import com.google.protobuf.StringValue;
-import io.grpc.Server;
-import io.grpc.stub.StreamObserver;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.spine3.base.Command;
-import org.spine3.base.CommandContext;
-import org.spine3.base.Commands;
-import org.spine3.base.Response;
-import org.spine3.base.Responses;
-import org.spine3.server.aggregate.Aggregate;
-import org.spine3.server.aggregate.AggregateRepository;
-import org.spine3.server.aggregate.Apply;
-import org.spine3.server.command.Assign;
-import org.spine3.server.command.CommandBus;
-import org.spine3.server.command.error.UnsupportedCommandException;
-import org.spine3.test.clientservice.Project;
-import org.spine3.test.clientservice.ProjectId;
-import org.spine3.test.clientservice.command.AddTask;
-import org.spine3.test.clientservice.command.CreateProject;
-import org.spine3.test.clientservice.command.StartProject;
-import org.spine3.test.clientservice.customer.Customer;
-import org.spine3.test.clientservice.customer.CustomerId;
-import org.spine3.test.clientservice.customer.command.CreateCustomer;
-import org.spine3.test.clientservice.customer.event.CustomerCreated;
-import org.spine3.test.clientservice.event.ProjectCreated;
-import org.spine3.test.clientservice.event.ProjectStarted;
-import org.spine3.test.clientservice.event.TaskAdded;
-import org.spine3.testdata.TestCommandBusFactory;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Set;
-
-import static com.google.common.collect.Lists.newArrayList;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.anyInt;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.spine3.testdata.TestBoundedContextFactory.newBoundedContext;
-import static org.spine3.testdata.TestCommandContextFactory.createCommandContext;
-
-@SuppressWarnings("InstanceMethodNamingConvention")
-public class ClientServiceShould {
-
-    private ClientService service;
-    private Server server;
-
-    private final Set<BoundedContext> boundedContexts = Sets.newHashSet();
-    private BoundedContext projectsContext;
-
-    private BoundedContext customersContext;
-    private final TestResponseObserver responseObserver = new TestResponseObserver();
-
-    @Before
-    public void setUp() {
-        // Create Projects Bounded Context with one repository.
-        projectsContext = newBoundedContext(spy(TestCommandBusFactory.create()));
-        final ProjectAggregateRepository projectRepo = new ProjectAggregateRepository(projectsContext);
-        projectsContext.register(projectRepo);
-        boundedContexts.add(projectsContext);
-
-        // Create Customers Bounded Context with one repository.
-        customersContext = newBoundedContext(spy(TestCommandBusFactory.create()));
-        final CustomerAggregateRepository customerRepo = new CustomerAggregateRepository(customersContext);
-        customersContext.register(customerRepo);
-        boundedContexts.add(customersContext);
-
-        // Expose two Bounded Contexts via a Client Service.
-        final ClientService.Builder builder = ClientService.newBuilder();
-        for (BoundedContext context : boundedContexts) {
-            builder.addBoundedContext(context);
-        }
-        service = spy(builder.build());
-        server = mock(Server.class);
-        doReturn(server).when(service).createGrpcServer(anyInt());
-    }
-
-    @After
-    public void tearDown() throws Exception {
-        if (!service.isShutdown()) {
-            service.shutdown();
-        }
-        for (BoundedContext boundedContext : boundedContexts) {
-            boundedContext.close();
-        }
-    }
-
-    @Test
-    public void post_commands_to_appropriate_bounded_context() {
-        verifyPostsCommand(Given.Command.createProject(), projectsContext.getCommandBus());
-        verifyPostsCommand(Given.Command.createCustomer(), customersContext.getCommandBus());
-    }
-
-    private void verifyPostsCommand(Command cmd, CommandBus commandBus) {
-        service.post(cmd, responseObserver);
-
-        assertEquals(Responses.ok(), responseObserver.getResponseHandled());
-        assertTrue(responseObserver.isCompleted());
-        assertNull(responseObserver.getThrowable());
-        verify(commandBus).post(cmd, responseObserver);
-    }
-
-    @Test
-    public void return_error_if_command_is_unsupported() {
-        final Command unsupportedCmd = Commands.create(StringValue.getDefaultInstance(), createCommandContext());
-
-        service.post(unsupportedCmd, responseObserver);
-
-        final Throwable exception = responseObserver.getThrowable().getCause();
-        assertEquals(UnsupportedCommandException.class, exception.getClass());
-    }
-
-    @Test
-    public void start_server() throws IOException {
-        service.start();
-
-        verify(server).start();
-    }
-
-    @Test
-    public void throw_exception_if_started_already() throws IOException {
-        service.start();
-        try {
-            service.start();
-        } catch (IllegalStateException expected) {
-            return;
-        }
-        fail("Exception must be thrown.");
-    }
-
-    @Test
-    public void await_termination() throws IOException, InterruptedException {
-        service.start();
-        service.awaitTermination();
-
-        verify(server).awaitTermination();
-    }
-
-    @Test(expected = IllegalStateException.class)
-    public void throw_exception_if_call_await_termination_on_not_started_service() {
-        service.awaitTermination();
-    }
-
-    @Test
-    public void assure_service_is_shutdown() throws IOException {
-        service.start();
-        service.shutdown();
-
-        assertTrue(service.isShutdown());
-    }
-
-    @Test
-    public void assure_service_was_not_started() throws IOException {
-        assertTrue(service.isShutdown());
-    }
-
-    @Test
-    public void assure_service_is_not_shut_down() throws IOException {
-        service.start();
-
-        assertFalse(service.isShutdown());
-    }
-
-    @Test
-    public void shutdown_itself() throws IOException, InterruptedException {
-        service.start();
-        service.shutdown();
-
-        verify(server).shutdown();
-    }
-
-    @Test(expected = IllegalStateException.class)
-    public void throw_exception_if_call_shutdown_on_not_started_service() {
-        service.shutdown();
-    }
-
-    @Test
-    public void throw_exception_if_shutdown_already() throws IOException {
-        service.start();
-        service.shutdown();
-        try {
-            service.shutdown();
-        } catch (IllegalStateException expected) {
-            return;
-        }
-        fail("Expected an exception.");
-    }
-
-    /*
-     * Stub repositories and aggregates
-     ***************************************************/
-
-    private static class ProjectAggregateRepository extends AggregateRepository<ProjectId, ProjectAggregate> {
-        private ProjectAggregateRepository(BoundedContext boundedContext) {
-            super(boundedContext);
-        }
-    }
-
-    private static class ProjectAggregate extends Aggregate<ProjectId, Project, Project.Builder> {
-        // an aggregate constructor must be public because it is used via reflection
-        @SuppressWarnings("PublicConstructorInNonPublicClass")
-        public ProjectAggregate(ProjectId id) {
-            super(id);
-        }
-
-        @Assign
-        public ProjectCreated handle(CreateProject cmd, CommandContext ctx) {
-            return Given.EventMessage.projectCreated(cmd.getProjectId());
-        }
-
-        @Assign
-        public TaskAdded handle(AddTask cmd, CommandContext ctx) {
-            return Given.EventMessage.taskAdded(cmd.getProjectId());
-        }
-
-        @Assign
-        public List<ProjectStarted> handle(StartProject cmd, CommandContext ctx) {
-            final ProjectStarted message =  Given.EventMessage.projectStarted(cmd.getProjectId());
-            return newArrayList(message);
-        }
-
-        @Apply
-        private void event(ProjectCreated event) {
-            getBuilder()
-                    .setId(event.getProjectId())
-                    .setStatus(Project.Status.CREATED)
-                    .build();
-        }
-
-        @Apply
-        private void event(TaskAdded event) {
-        }
-
-        @Apply
-        private void event(ProjectStarted event) {
-            getBuilder()
-                    .setId(event.getProjectId())
-                    .setStatus(Project.Status.STARTED)
-                    .build();
-        }
-    }
-
-    private static class CustomerAggregateRepository extends AggregateRepository<CustomerId, CustomerAggregate> {
-        private CustomerAggregateRepository(BoundedContext boundedContext) {
-            super(boundedContext);
-        }
-    }
-
-    private static class CustomerAggregate extends Aggregate<CustomerId, Customer, Customer.Builder> {
-
-        @SuppressWarnings("PublicConstructorInNonPublicClass") // by convention (as it's used by Reflection).
-        public CustomerAggregate(CustomerId id) {
-            super(id);
-        }
-
-        @Assign
-        public CustomerCreated handle(CreateCustomer cmd, CommandContext ctx) {
-            final CustomerCreated event = CustomerCreated.newBuilder()
-                                                         .setCustomerId(cmd.getCustomerId())
-                                                         .setCustomer(cmd.getCustomer())
-                                                         .build();
-            return event;
-        }
-
-        @Apply
-        private void event(CustomerCreated event) {
-            incrementState(event.getCustomer());
-        }
-    }
-
-    private static class TestResponseObserver implements StreamObserver<Response> {
-
-        private Response responseHandled;
-        private Throwable throwable;
-        private boolean isCompleted = false;
-
-        @Override
-        public void onNext(Response response) {
-            this.responseHandled = response;
-        }
-
-        @Override
-        public void onError(Throwable throwable) {
-            this.throwable = throwable;
-        }
-
-        @Override
-        public void onCompleted() {
-            this.isCompleted = true;
-        }
-
-        /* package */ Response getResponseHandled() {
-            return responseHandled;
-        }
-
-        /* package */ Throwable getThrowable() {
-            return throwable;
-        }
-
-        /* package */ boolean isCompleted() {
-            return isCompleted;
-        }
-    }
-}
diff --git a/server/src/test/java/org/spine3/server/CommandServiceShould.java b/server/src/test/java/org/spine3/server/CommandServiceShould.java
new file mode 100644
index 00000000000..8d695d0ee0e
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/CommandServiceShould.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server;
+
+import com.google.common.collect.Sets;
+import com.google.protobuf.StringValue;
+import io.grpc.stub.StreamObserver;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.spine3.base.Command;
+import org.spine3.base.Commands;
+import org.spine3.base.Response;
+import org.spine3.base.Responses;
+import org.spine3.server.command.CommandBus;
+import org.spine3.server.command.error.UnsupportedCommandException;
+import org.spine3.server.transport.GrpcContainer;
+import org.spine3.testdata.TestCommandBusFactory;
+
+import java.io.IOException;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.spine3.testdata.TestBoundedContextFactory.newBoundedContext;
+import static org.spine3.testdata.TestCommandContextFactory.createCommandContext;
+
+@SuppressWarnings("InstanceMethodNamingConvention")
+public class CommandServiceShould {
+
+    private CommandService service;
+
+    private final Set<BoundedContext> boundedContexts = Sets.newHashSet();
+    private BoundedContext projectsContext;
+
+    private BoundedContext customersContext;
+    private final TestResponseObserver responseObserver = new TestResponseObserver();
+
+    @Before
+    public void setUp() {
+        // Create Projects Bounded Context with one repository.
+        projectsContext = newBoundedContext(spy(TestCommandBusFactory.create()));
+        final Given.ProjectAggregateRepository projectRepo = new Given.ProjectAggregateRepository(projectsContext);
+        projectsContext.register(projectRepo);
+        boundedContexts.add(projectsContext);
+
+        // Create Customers Bounded Context with one repository.
+        customersContext = newBoundedContext(spy(TestCommandBusFactory.create()));
+        final Given.CustomerAggregateRepository customerRepo = new Given.CustomerAggregateRepository(customersContext);
+        customersContext.register(customerRepo);
+        boundedContexts.add(customersContext);
+
+        // Expose two Bounded Contexts via an instance of {@code CommandService}.
+        final CommandService.Builder builder = CommandService.newBuilder();
+        for (BoundedContext context : boundedContexts) {
+            builder.addBoundedContext(context);
+        }
+        service = spy(builder.build());
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        for (BoundedContext boundedContext : boundedContexts) {
+            boundedContext.close();
+        }
+    }
+
+    @Test
+    public void post_commands_to_appropriate_bounded_context() {
+        verifyPostsCommand(Given.Command.createProject(), projectsContext.getCommandBus());
+        verifyPostsCommand(Given.Command.createCustomer(), customersContext.getCommandBus());
+    }
+
+    @Test
+    public void never_retrieve_removed_bounded_contexts_from_builder() {
+        final CommandService.Builder builder = CommandService.newBuilder()
+                                                             .addBoundedContext(projectsContext)
+                                                             .addBoundedContext(customersContext)
+                                                             .removeBoundedContext(projectsContext);
+
+        final CommandService service = builder.build(); // Creates BoundedContext map
+        assertNotNull(service);
+
+        assertTrue(builder.getBoundedContextMap()
+                          .containsValue(customersContext));
+        assertFalse(builder.getBoundedContextMap()
+                           .containsValue(projectsContext));
+    }
+
+    private void verifyPostsCommand(Command cmd, CommandBus commandBus) {
+        service.post(cmd, responseObserver);
+
+        assertEquals(Responses.ok(), responseObserver.getResponseHandled());
+        assertTrue(responseObserver.isCompleted());
+        assertNull(responseObserver.getThrowable());
+        verify(commandBus).post(cmd, responseObserver);
+    }
+
+    @Test
+    public void return_error_if_command_is_unsupported() {
+        final Command unsupportedCmd = Commands.create(StringValue.getDefaultInstance(), createCommandContext());
+
+        service.post(unsupportedCmd, responseObserver);
+
+        final Throwable exception = responseObserver.getThrowable()
+                                                    .getCause();
+        assertEquals(UnsupportedCommandException.class, exception.getClass());
+    }
+
+    @Test
+    public void deploy_to_grpc_container() throws IOException {
+        final GrpcContainer grpcContainer = GrpcContainer.newBuilder()
+                                                         .addService(service)
+                                                         .build();
+        try {
+            assertTrue(grpcContainer.isScheduledForDeployment(service));
+
+            grpcContainer.start();
+            assertTrue(grpcContainer.isLive(service));
+
+            grpcContainer.shutdown();
+            assertFalse(grpcContainer.isLive(service));
+        } finally {
+            if (!grpcContainer.isShutdown()) {
+                grpcContainer.shutdown();
+            }
+        }
+    }
+
+    /*
+     * Stub repositories and aggregates
+     ***************************************************/
+
+    private static class TestResponseObserver implements StreamObserver<Response> {
+
+        private Response responseHandled;
+        private Throwable throwable;
+        private boolean isCompleted = false;
+
+        @Override
+        public void onNext(Response response) {
+            this.responseHandled = response;
+        }
+
+        @Override
+        public void onError(Throwable throwable) {
+            this.throwable = throwable;
+        }
+
+        @Override
+        public void onCompleted() {
+            this.isCompleted = true;
+        }
+
+        /* package */ Response getResponseHandled() {
+            return responseHandled;
+        }
+
+        /* package */ Throwable getThrowable() {
+            return throwable;
+        }
+
+        /* package */ boolean isCompleted() {
+            return isCompleted;
+        }
+    }
+}
diff --git a/server/src/test/java/org/spine3/server/Given.java b/server/src/test/java/org/spine3/server/Given.java
index 1b7dbd3cab4..4322c2f936e 100644
--- a/server/src/test/java/org/spine3/server/Given.java
+++ b/server/src/test/java/org/spine3/server/Given.java
@@ -25,25 +25,38 @@
 import org.spine3.base.CommandContext;
 import org.spine3.base.Commands;
 import org.spine3.base.Identifiers;
+import org.spine3.client.Target;
 import org.spine3.people.PersonName;
-import org.spine3.test.clientservice.ProjectId;
-import org.spine3.test.clientservice.command.CreateProject;
-import org.spine3.test.clientservice.customer.Customer;
-import org.spine3.test.clientservice.customer.CustomerId;
-import org.spine3.test.clientservice.customer.command.CreateCustomer;
-import org.spine3.test.clientservice.event.ProjectCreated;
-import org.spine3.test.clientservice.event.ProjectStarted;
-import org.spine3.test.clientservice.event.TaskAdded;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.aggregate.Aggregate;
+import org.spine3.server.aggregate.AggregateRepository;
+import org.spine3.server.aggregate.Apply;
+import org.spine3.server.command.Assign;
+import org.spine3.test.aggregate.Project;
+import org.spine3.test.aggregate.ProjectId;
+import org.spine3.test.aggregate.command.AddTask;
+import org.spine3.test.aggregate.command.CreateProject;
+import org.spine3.test.aggregate.command.StartProject;
+import org.spine3.test.aggregate.event.ProjectCreated;
+import org.spine3.test.aggregate.event.ProjectStarted;
+import org.spine3.test.aggregate.event.TaskAdded;
+import org.spine3.test.commandservice.customer.Customer;
+import org.spine3.test.commandservice.customer.CustomerId;
+import org.spine3.test.commandservice.customer.command.CreateCustomer;
+import org.spine3.test.commandservice.customer.event.CustomerCreated;
 import org.spine3.time.LocalDate;
 import org.spine3.time.LocalDates;
 import org.spine3.users.UserId;
 
+import java.util.List;
+
+import static com.google.common.collect.Lists.newArrayList;
 import static org.spine3.base.Identifiers.newUuid;
 import static org.spine3.protobuf.Timestamps.getCurrentTime;
 import static org.spine3.test.Tests.newUserId;
 import static org.spine3.testdata.TestCommandContextFactory.createCommandContext;
 
-/* package */ class Given {
+public class Given {
 
     /* package */ static class AggregateId {
 
@@ -148,4 +161,102 @@ private Command() {}
             return result;
         }
     }
+
+    /* package */ static class Query {
+
+        private Query() {};
+
+        /* package */ static org.spine3.client.Query readAllProjects() {
+
+            final String typeName = TypeUrl.of(org.spine3.test.projection.Project.class)
+                                           .getTypeName();
+            final Target queryTarget = Target.newBuilder()
+                                             .setType(typeName)
+                                             .setIncludeAll(true)
+                                             .build();
+
+            final org.spine3.client.Query query = org.spine3.client.Query.newBuilder()
+                                                                         .setTarget(queryTarget)
+                                                                         .build();
+            return query;
+        }
+    }
+
+    /* package */ static class ProjectAggregateRepository extends AggregateRepository<ProjectId, ProjectAggregate> {
+        /* package */ ProjectAggregateRepository(BoundedContext boundedContext) {
+            super(boundedContext);
+        }
+    }
+
+    private static class ProjectAggregate extends Aggregate<ProjectId, Project, Project.Builder> {
+        // an aggregate constructor must be public because it is used via reflection
+        @SuppressWarnings("PublicConstructorInNonPublicClass")
+        public ProjectAggregate(ProjectId id) {
+            super(id);
+        }
+
+        @Assign
+        public ProjectCreated handle(CreateProject cmd, CommandContext ctx) {
+            return EventMessage.projectCreated(cmd.getProjectId());
+        }
+
+        @Assign
+        public TaskAdded handle(AddTask cmd, CommandContext ctx) {
+            return EventMessage.taskAdded(cmd.getProjectId());
+        }
+
+        @Assign
+        public List<ProjectStarted> handle(StartProject cmd, CommandContext ctx) {
+            final ProjectStarted message = EventMessage.projectStarted(cmd.getProjectId());
+            return newArrayList(message);
+        }
+
+        @Apply
+        private void event(ProjectCreated event) {
+            getBuilder()
+                    .setId(event.getProjectId())
+                    .setStatus(Project.Status.CREATED)
+                    .build();
+        }
+
+        @Apply
+        private void event(TaskAdded event) {
+        }
+
+        @Apply
+        private void event(ProjectStarted event) {
+            getBuilder()
+                    .setId(event.getProjectId())
+                    .setStatus(Project.Status.STARTED)
+                    .build();
+        }
+    }
+
+    public static class CustomerAggregateRepository extends AggregateRepository<CustomerId, CustomerAggregate> {
+        public CustomerAggregateRepository(BoundedContext boundedContext) {
+            super(boundedContext);
+        }
+    }
+
+    public static class CustomerAggregate extends Aggregate<CustomerId, Customer, Customer.Builder> {
+
+        @SuppressWarnings("PublicConstructorInNonPublicClass") // by convention (as it's used by Reflection).
+        public CustomerAggregate(CustomerId id) {
+            super(id);
+        }
+
+        @Assign
+        public CustomerCreated handle(CreateCustomer cmd, CommandContext ctx) {
+            final CustomerCreated event = CustomerCreated.newBuilder()
+                                                         .setCustomerId(cmd.getCustomerId())
+                                                         .setCustomer(cmd.getCustomer())
+                                                         .build();
+            return event;
+        }
+
+        @Apply
+        private void event(CustomerCreated event) {
+            incrementState(event.getCustomer());
+        }
+    }
 }
diff --git a/server/src/test/java/org/spine3/server/QueryServiceShould.java b/server/src/test/java/org/spine3/server/QueryServiceShould.java
new file mode 100644
index 00000000000..66fc3611e7a
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/QueryServiceShould.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server;
+
+import com.google.common.collect.Sets;
+import io.grpc.stub.StreamObserver;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.spine3.base.EventContext;
+import org.spine3.base.Responses;
+import org.spine3.client.Query;
+import org.spine3.client.QueryResponse;
+import org.spine3.server.event.Subscribe;
+import org.spine3.server.projection.Projection;
+import org.spine3.server.projection.ProjectionRepository;
+import org.spine3.server.stand.Stand;
+import org.spine3.test.bc.event.ProjectCreated;
+import org.spine3.test.commandservice.ProjectId;
+import org.spine3.test.projection.Project;
+import org.spine3.testdata.TestStandFactory;
+
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.spine3.testdata.TestBoundedContextFactory.newBoundedContext;
+
+/**
+ * @author Alex Tymchenko
+ */
+public class QueryServiceShould {
+
+    private QueryService service;
+
+    private final Set<BoundedContext> boundedContexts = Sets.newHashSet();
+
+    private BoundedContext projectsContext;
+    private BoundedContext customersContext;
+    private final TestQueryResponseObserver responseObserver = new TestQueryResponseObserver();
+    private ProjectDetailsRepository projectDetailsRepository;
+
+    @Before
+    public void setUp() {
+        // Create Projects Bounded Context with one repository and one projection.
+        projectsContext = newBoundedContext(spy(TestStandFactory.create()));
+
+        final Given.ProjectAggregateRepository projectRepo = new Given.ProjectAggregateRepository(projectsContext);
+        projectsContext.register(projectRepo);
+        projectDetailsRepository = spy(new ProjectDetailsRepository(projectsContext));
+        projectsContext.register(projectDetailsRepository);
+
+        boundedContexts.add(projectsContext);
+
+        // Create Customers Bounded Context with one repository.
+        customersContext = newBoundedContext(spy(TestStandFactory.create()));
+        final Given.CustomerAggregateRepository customerRepo = new Given.CustomerAggregateRepository(customersContext);
+        customersContext.register(customerRepo);
+        boundedContexts.add(customersContext);
+
+        final QueryService.Builder builder = QueryService.newBuilder();
+
+        for (BoundedContext context : boundedContexts) {
+            builder.addBoundedContext(context);
+        }
+
+        service = spy(builder.build());
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        for (BoundedContext boundedContext : boundedContexts) {
+            boundedContext.close();
+        }
+    }
+
+    @Test
+    public void execute_queries() {
+        final Query query = Given.Query.readAllProjects();
+        service.read(query, responseObserver);
+        checkOkResponse(responseObserver);
+    }
+
+    @Test
+    public void dispatch_queries_to_proper_bounded_context() {
+        final Query query = Given.Query.readAllProjects();
+        final Stand stand = projectsContext.getStand();
+        service.read(query, responseObserver);
+
+        checkOkResponse(responseObserver);
+        verify(stand).execute(query, responseObserver);
+
+        verify(customersContext.getStand(), never()).execute(query, responseObserver);
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void fail_to_create_with_removed_bounded_context_from_builder() {
+        final BoundedContext boundedContext = newBoundedContext(TestStandFactory.create());
+
+        final QueryService.Builder builder = QueryService.newBuilder();
+        builder.addBoundedContext(boundedContext)
+               .removeBoundedContext(boundedContext)
+               .build();
+    }
+
+    @SuppressWarnings("ResultOfMethodCallIgnored")
+    @Test(expected = IllegalStateException.class)
+    public void fail_to_create_with_no_bounded_context() {
+        QueryService.newBuilder()
+                    .build();
+    }
+
+    @Test
+    public void return_error_if_query_failed_to_execute() {
+        when(projectDetailsRepository.loadAll()).thenThrow(RuntimeException.class);
+        final Query query = Given.Query.readAllProjects();
+        service.read(query, responseObserver);
+        checkFailureResponse(responseObserver);
+    }
+
+    private static void checkOkResponse(TestQueryResponseObserver responseObserver) {
+        final QueryResponse responseHandled = responseObserver.getResponseHandled();
+        assertNotNull(responseHandled);
+        assertEquals(Responses.ok(), responseHandled.getResponse());
+        assertTrue(responseObserver.isCompleted());
+        assertNull(responseObserver.getThrowable());
+    }
+
+    private static void checkFailureResponse(TestQueryResponseObserver responseObserver) {
+        final QueryResponse responseHandled = responseObserver.getResponseHandled();
+        assertNull(responseHandled);
+        assertFalse(responseObserver.isCompleted());
+        assertNotNull(responseObserver.getThrowable());
+    }
+
+    /*
+     * Stub repositories and projections
+     ***************************************************/
+
+    private static class ProjectDetailsRepository extends ProjectionRepository<ProjectId, ProjectDetails, Project> {
+
+        protected ProjectDetailsRepository(BoundedContext boundedContext) {
+            super(boundedContext);
+        }
+    }
+
+    private static class ProjectDetails extends Projection<ProjectId, Project> {
+
+        /**
+         * Creates a new instance.
+         *
+         * @param id the ID for the new instance
+         * @throws IllegalArgumentException if the ID is not of one of the supported types
+         */
+        public ProjectDetails(ProjectId id) {
+            super(id);
+        }
+
+        @SuppressWarnings("UnusedParameters") // OK for test method.
+        @Subscribe
+        public void on(ProjectCreated event, EventContext context) {
+            // Do nothing.
+        }
+    }
+
+    private static class TestQueryResponseObserver implements StreamObserver<QueryResponse> {
+
+        private QueryResponse responseHandled;
+        private Throwable throwable;
+        private boolean isCompleted = false;
+
+        @Override
+        public void onNext(QueryResponse response) {
+            this.responseHandled = response;
+        }
+
+        @Override
+        public void onError(Throwable throwable) {
+            this.throwable = throwable;
+        }
+
+        @Override
+        public void onCompleted() {
+            this.isCompleted = true;
+        }
+
+        /* package */ QueryResponse getResponseHandled() {
+            return responseHandled;
+        }
+
+        /* package */ Throwable getThrowable() {
+            return throwable;
+        }
+
+        /* package */ boolean isCompleted() {
+            return isCompleted;
+        }
+    }
+}
diff --git a/server/src/test/java/org/spine3/server/SubscriptionServiceShould.java b/server/src/test/java/org/spine3/server/SubscriptionServiceShould.java
new file mode 100644
index 00000000000..0dface7177a
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/SubscriptionServiceShould.java
@@ -0,0 +1,350 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server;
+
+import com.google.protobuf.Message;
+import io.grpc.stub.StreamObserver;
+import org.junit.Test;
+import org.spine3.base.Queries;
+import org.spine3.base.Response;
+import org.spine3.client.Subscription;
+import org.spine3.client.SubscriptionUpdate;
+import org.spine3.client.Target;
+import org.spine3.client.Topic;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.server.stand.Stand;
+import org.spine3.test.aggregate.Project;
+import org.spine3.test.aggregate.ProjectId;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.spine3.test.Verify.assertInstanceOf;
+import static org.spine3.test.Verify.assertSize;
+import static org.spine3.testdata.TestBoundedContextFactory.newBoundedContext;
+
+/**
+ * @author Dmytro Dashenkov
+ */
+public class SubscriptionServiceShould {
+
+    /*
+     * Creation tests
+     * --------------
+     */
+
+    @Test
+    public void initialize_properly_with_one_bounded_context() {
+        final BoundedContext singleBoundedContext = newBoundedContext("Single", newSimpleStand());
+
+        final SubscriptionService.Builder builder = SubscriptionService.newBuilder()
+                                                                       .addBoundedContext(singleBoundedContext);
+
+        final SubscriptionService subscriptionService = builder.build();
+        assertNotNull(subscriptionService);
+
+        final List<BoundedContext> boundedContexs = builder.getBoundedContexts();
+        assertSize(1, boundedContexs);
+        assertTrue(boundedContexs.contains(singleBoundedContext));
+    }
+
+    @Test
+    public void initialize_properly_with_several_bounded_contexts() {
+        final BoundedContext firstBoundedContext = newBoundedContext("First", newSimpleStand());
+        final BoundedContext secondBoundedContext = newBoundedContext("Second", newSimpleStand());
+        final BoundedContext thirdBoundedContext = newBoundedContext("Third", newSimpleStand());
+
+        final SubscriptionService.Builder builder = SubscriptionService.newBuilder()
+                                                                       .addBoundedContext(firstBoundedContext)
+                                                                       .addBoundedContext(secondBoundedContext)
+                                                                       .addBoundedContext(thirdBoundedContext);
+        final SubscriptionService service = builder.build();
+        assertNotNull(service);
+
+        final List<BoundedContext> boundedContexts = builder.getBoundedContexts();
+        assertSize(3, boundedContexts);
+        assertTrue(boundedContexts.contains(firstBoundedContext));
+        assertTrue(boundedContexts.contains(secondBoundedContext));
+        assertTrue(boundedContexts.contains(thirdBoundedContext));
+    }
+
+    @Test
+    public void be_able_to_remove_bounded_context_from_builder() {
+        final BoundedContext firstBoundedContext = newBoundedContext("Removed", newSimpleStand());
+        final BoundedContext secondBoundedContext = newBoundedContext("Also removed", newSimpleStand());
+        final BoundedContext thirdBoundedContext = newBoundedContext("The one to stay", newSimpleStand());
+
+        final SubscriptionService.Builder builder = SubscriptionService.newBuilder()
+                                                                       .addBoundedContext(firstBoundedContext)
+                                                                       .addBoundedContext(secondBoundedContext)
+                                                                       .addBoundedContext(thirdBoundedContext)
+                                                                       .removeBoundedContext(secondBoundedContext)
+                                                                       .removeBoundedContext(firstBoundedContext);
+        final SubscriptionService subscriptionService = builder.build();
+        assertNotNull(subscriptionService);
+
+        final List<BoundedContext> boundedContexts = builder.getBoundedContexts();
+        assertSize(1, boundedContexts);
+        assertFalse(boundedContexts.contains(firstBoundedContext));
+        assertFalse(boundedContexts.contains(secondBoundedContext));
+        assertTrue(boundedContexts.contains(thirdBoundedContext));
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void fail_to_initialize_from_empty_builder() {
+        SubscriptionService.newBuilder()
+                           .build();
+    }
+
+    /*
+    * Subscription tests
+    * ------------------
+    */
+
+    @Test
+    public void subscribe_to_topic() {
+        final BoundedContext boundedContext = setupBoundedContextForAggregateRepo();
+
+        final SubscriptionService subscriptionService = SubscriptionService.newBuilder()
+                                                                           .addBoundedContext(boundedContext)
+                                                                           .build();
+        final String type = boundedContext.getStand()
+                                          .getExposedTypes()
+                                          .iterator()
+                                          .next()
+                                          .getTypeName();
+        final Target target = getProjectQueryTarget();
+
+        assertEquals(type, target.getType());
+
+        final Topic topic = Topic.newBuilder()
+                                 .setTarget(target)
+                                 .build();
+
+        final MemoizeStreamObserver<Subscription> observer = new MemoizeStreamObserver<>();
+
+        subscriptionService.subscribe(topic, observer);
+
+        assertNotNull(observer.streamFlowValue);
+        assertTrue(observer.streamFlowValue.isInitialized());
+        assertEquals(observer.streamFlowValue.getType(), type);
+
+        assertNull(observer.throwable);
+        assertTrue(observer.isCompleted);
+    }
+
+    @Test
+    public void handle_subscription_process_exceptions_and_call_observer_error_callback() {
+        final BoundedContext boundedContext = setupBoundedContextForAggregateRepo();
+
+        final SubscriptionService subscriptionService = SubscriptionService.newBuilder()
+                                                                           .addBoundedContext(boundedContext)
+                                                                           .build();
+        final MemoizeStreamObserver<Subscription> observer = new MemoizeStreamObserver<>();
+        // Causes NPE
+        subscriptionService.subscribe(null, observer);
+        assertNull(observer.streamFlowValue);
+        assertFalse(observer.isCompleted);
+        assertNotNull(observer.throwable);
+        assertInstanceOf(NullPointerException.class, observer.throwable);
+    }
+
+    @Test
+    public void activate_subscription() {
+        final BoundedContext boundedContext = setupBoundedContextForAggregateRepo();
+
+        final SubscriptionService subscriptionService = SubscriptionService.newBuilder()
+                                                                           .addBoundedContext(boundedContext)
+                                                                           .build();
+        final Target target = getProjectQueryTarget();
+
+        final Topic topic = Topic.newBuilder()
+                                 .setTarget(target)
+                                 .build();
+        // Subscribe on the topic
+        final MemoizeStreamObserver<Subscription> subscriptionObserver = new MemoizeStreamObserver<>();
+        subscriptionService.subscribe(topic, subscriptionObserver);
+        subscriptionObserver.verifyState();
+
+        // Activate subscription
+        final MemoizeStreamObserver<SubscriptionUpdate> activationObserver = new MemoizeStreamObserver<>();
+        subscriptionService.activate(subscriptionObserver.streamFlowValue, activationObserver);
+
+        // Post update to Stand directly
+        final ProjectId projectId = ProjectId.newBuilder()
+                                             .setId("some-id")
+                                             .build();
+        final Message projectState = Project.newBuilder()
+                                            .setId(projectId)
+                                            .build();
+        boundedContext.getStandFunnel()
+                      .post(projectId, AnyPacker.pack(projectState));
+
+        // isCompleted set to false since we don't expect activationObserver::onCompleted to be called.
+        activationObserver.verifyState(false);
+    }
+
+    @Test
+    public void handle_activation_process_exceptions_and_call_observer_error_callback() {
+        final BoundedContext boundedContext = setupBoundedContextForAggregateRepo();
+
+        final SubscriptionService subscriptionService = SubscriptionService.newBuilder()
+                                                                           .addBoundedContext(boundedContext)
+                                                                           .build();
+        final MemoizeStreamObserver<SubscriptionUpdate> observer = new MemoizeStreamObserver<>();
+        // Causes NPE
+        subscriptionService.activate(null, observer);
+        assertNull(observer.streamFlowValue);
+        assertFalse(observer.isCompleted);
+        assertNotNull(observer.throwable);
+        assertInstanceOf(NullPointerException.class, observer.throwable);
+    }
+
+    @Test
+    public void cancel_subscription_on_topic() {
+        final BoundedContext boundedContext = setupBoundedContextForAggregateRepo();
+
+        final SubscriptionService subscriptionService = SubscriptionService.newBuilder()
+                                                                           .addBoundedContext(boundedContext)
+                                                                           .build();
+
+        final Target target = getProjectQueryTarget();
+
+        final Topic topic = Topic.newBuilder()
+                                 .setTarget(target)
+                                 .build();
+
+        // Subscribe
+        final MemoizeStreamObserver<Subscription> subscribeObserver = new MemoizeStreamObserver<>();
+        subscriptionService.subscribe(topic, subscribeObserver);
+
+        // Activate subscription
+        final MemoizeStreamObserver<SubscriptionUpdate> activateSubscription = spy(new MemoizeStreamObserver<SubscriptionUpdate>());
+        subscriptionService.activate(subscribeObserver.streamFlowValue, activateSubscription);
+
+        // Cancel subscription
+        subscriptionService.cancel(subscribeObserver.streamFlowValue, new MemoizeStreamObserver<Response>());
+
+        // Post update to Stand
+        final ProjectId projectId = ProjectId.newBuilder()
+                                             .setId("some-other-id")
+                                             .build();
+        final Message projectState = Project.newBuilder()
+                                            .setId(projectId)
+                                            .build();
+        boundedContext.getStandFunnel()
+                      .post(projectId, AnyPacker.pack(projectState));
+
+        // The update must not be handled by the observer
+        verify(activateSubscription, never()).onNext(any(SubscriptionUpdate.class));
+        verify(activateSubscription, never()).onCompleted();
+    }
+
+    @Test
+    public void handle_cancellation_process_exceptions_and_call_observer_error_callback() {
+        final BoundedContext boundedContext = setupBoundedContextForAggregateRepo();
+
+        final SubscriptionService subscriptionService = SubscriptionService.newBuilder()
+                                                                           .addBoundedContext(boundedContext)
+                                                                           .build();
+        final Target target = getProjectQueryTarget();
+        final Topic topic = Topic.newBuilder()
+                                 .setTarget(target)
+                                 .build();
+        final MemoizeStreamObserver<Subscription> subscriptionObserver = new MemoizeStreamObserver<>();
+        subscriptionService.subscribe(topic, subscriptionObserver);
+
+        final String failureMessage = "Execution breaking exception";
+        final MemoizeStreamObserver<Response> observer = new MemoizeStreamObserver<Response>() {
+            @Override
+            public void onNext(Response value) {
+                super.onNext(value);
+                throw new RuntimeException(failureMessage);
+            }
+        };
+        subscriptionService.cancel(subscriptionObserver.streamFlowValue, observer);
+        assertNotNull(observer.streamFlowValue);
+        assertFalse(observer.isCompleted);
+        assertNotNull(observer.throwable);
+        assertInstanceOf(RuntimeException.class, observer.throwable);
+        assertEquals(observer.throwable.getMessage(), failureMessage);
+    }
+
+    private static BoundedContext setupBoundedContextForAggregateRepo() {
+        final Stand stand = Stand.newBuilder()
+                                 .build();
+
+        final BoundedContext boundedContext = newBoundedContext(stand);
+
+        stand.registerTypeSupplier(new Given.ProjectAggregateRepository(boundedContext));
+
+        return boundedContext;
+    }
+
+    private static Target getProjectQueryTarget() {
+        return Queries.Targets.allOf(Project.class);
+    }
+
+    private static Stand newSimpleStand() {
+        return Stand.newBuilder()
+                    .build();
+    }
+
+    private static class MemoizeStreamObserver<T> implements StreamObserver<T> {
+
+        private T streamFlowValue;
+        private Throwable throwable;
+        private boolean isCompleted;
+
+        @Override
+        public void onNext(T value) {
+            this.streamFlowValue = value;
+        }
+
+        @Override
+        public void onError(Throwable t) {
+            this.throwable = t;
+        }
+
+        @Override
+        public void onCompleted() {
+            this.isCompleted = true;
+        }
+
+        private void verifyState() {
+            verifyState(true);
+        }
+
+        private void verifyState(boolean isCompleted) {
+            assertNotNull(streamFlowValue);
+            assertNull(throwable);
+            assertEquals(this.isCompleted, isCompleted);
+        }
+    }
+}
diff --git a/server/src/test/java/org/spine3/server/bc/BoundedContextShould.java b/server/src/test/java/org/spine3/server/bc/BoundedContextShould.java
index a8dbb28ce2e..376883694c8 100644
--- a/server/src/test/java/org/spine3/server/bc/BoundedContextShould.java
+++ b/server/src/test/java/org/spine3/server/bc/BoundedContextShould.java
@@ -47,6 +47,7 @@
 import org.spine3.server.procman.ProcessManagerRepository;
 import org.spine3.server.projection.Projection;
 import org.spine3.server.projection.ProjectionRepository;
+import org.spine3.server.stand.Stand;
 import org.spine3.server.storage.StorageFactory;
 import org.spine3.server.storage.memory.InMemoryStorageFactory;
 import org.spine3.server.type.EventClass;
@@ -68,6 +69,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
@@ -194,6 +196,17 @@ public void not_change_storage_during_registration_if_a_repository_has_one() {
         verify(spy, never()).initStorage(any(StorageFactory.class));
     }
 
+    @Test
+    public void propagate_registered_repositories_to_stand() {
+        final Stand stand = spy(mock(Stand.class));
+        final BoundedContext boundedContext = newBoundedContext(stand);
+        verify(stand, never()).registerTypeSupplier(any(Repository.class));
+
+        final ProjectAggregateRepository repository = new ProjectAggregateRepository(boundedContext);
+        boundedContext.register(repository);
+        verify(stand).registerTypeSupplier(eq(repository));
+    }
+
     /** Returns {@link Mockito#any()} matcher for response observer. */
     @SuppressWarnings("unchecked")
     private static StreamObserver<Response> anyResponseObserver() {
diff --git a/server/src/test/java/org/spine3/server/command/ExecutorCommandSchedulerShould.java b/server/src/test/java/org/spine3/server/command/ExecutorCommandSchedulerShould.java
index c4e9f52dc27..8c9ee147d53 100644
--- a/server/src/test/java/org/spine3/server/command/ExecutorCommandSchedulerShould.java
+++ b/server/src/test/java/org/spine3/server/command/ExecutorCommandSchedulerShould.java
@@ -32,10 +32,10 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
-import static org.mockito.Mockito.after;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.verify;
 import static org.spine3.base.Identifiers.newUuid;
 import static org.spine3.protobuf.Durations.milliseconds;
@@ -51,6 +51,9 @@ public class ExecutorCommandSchedulerShould {
 
     private static final Duration DELAY = milliseconds(DELAY_MS);
 
+    // Wait a bit longer in the verifier to ensure the command was processed.
+    private static final int WAIT_FOR_PROPAGATION_MS = 300;
+
     private CommandScheduler scheduler;
     private CommandContext context;
 
@@ -73,7 +76,7 @@ public void schedule_command_if_delay_is_set() {
         scheduler.schedule(cmdPrimary);
         
         verify(scheduler, never()).post(any(Command.class));
-        verify(scheduler, after(DELAY_MS)).post(commandCaptor.capture());
+        verify(scheduler, timeout(DELAY_MS + WAIT_FOR_PROPAGATION_MS)).post(commandCaptor.capture());
         final Command actualCmd = commandCaptor.getValue();
         final Command expectedCmd = Commands.setSchedulingTime(cmdPrimary, getSchedulingTime(actualCmd));
         assertEquals(expectedCmd, actualCmd);
@@ -88,7 +91,7 @@ public void not_schedule_command_with_same_id_twice() {
         scheduler.schedule(expectedCmd);
         scheduler.schedule(extraCmd);
 
-        verify(scheduler, after(DELAY_MS)).post(any(Command.class));
+        verify(scheduler, timeout(DELAY_MS + WAIT_FOR_PROPAGATION_MS)).post(any(Command.class));
         verify(scheduler, never()).post(extraCmd);
     }
 
diff --git a/server/src/test/java/org/spine3/server/entity/AbstractEntityRepositoryShould.java b/server/src/test/java/org/spine3/server/entity/AbstractEntityRepositoryShould.java
new file mode 100644
index 00000000000..7addf37da97
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/entity/AbstractEntityRepositoryShould.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.entity;
+
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.Message;
+import org.junit.Test;
+import org.spine3.client.EntityFilters;
+import org.spine3.client.EntityId;
+import org.spine3.client.EntityIdFilter;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.test.Tests;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.spine3.test.Verify.assertContains;
+import static org.spine3.test.Verify.assertSize;
+
+/**
+ * @author Dmytro Dashenkov
+ */
+public abstract class AbstractEntityRepositoryShould<E extends Entity<I, S>, I, S extends Message> {
+
+    @Test
+    public void find_single_entity_by_id() {
+        final EntityRepository<I, E, S> repo = repository();
+
+        final E entity = entity();
+
+        repo.store(entity);
+
+        final Entity<?, ?> found = repo.load(entity.getId());
+
+        assertEquals(found, entity);
+    }
+
+    @SuppressWarnings("MethodWithMultipleLoops")
+    @Test
+    public void find_multiple_entities_by_ids() {
+        final EntityRepository<I, E, S> repo = repository();
+
+        final int count = 10;
+        final List<E> entities = entities(count);
+
+        for (E entity : entities) {
+            repo.store(entity);
+        }
+
+        final List<I> ids = new LinkedList<>();
+
+        // Find some of the records (half of them in this case)
+        for (int i = 0; i < count / 2; i++) {
+            ids.add(entities.get(i)
+                            .getId());
+        }
+
+        final Collection<E> found = repo.loadAll(ids);
+
+        assertSize(ids.size(), found);
+
+        for (E entity : found) {
+            assertContains(entity, entities);
+        }
+    }
+
+    @SuppressWarnings("MethodWithMultipleLoops")
+    @Test
+    public void find_all_entities() {
+        final EntityRepository<I, E, S> repo = repository();
+
+        final int count = 150;
+        final List<E> entities = entities(count);
+
+        for (E entity : entities) {
+            repo.store(entity);
+        }
+        final Collection<E> found = repo.loadAll();
+        assertSize(entities.size(), found);
+
+        for (E entity : found) {
+            assertContains(entity, entities);
+        }
+    }
+
+    @Test
+    public void find_no_entities_if_empty() {
+        final EntityRepository<I, E, S> repo = repository();
+
+        final Collection<E> found = repo.loadAll();
+        assertSize(0, found);
+    }
+
+    @SuppressWarnings("MethodWithMultipleLoops")
+    @Test
+    public void handle_wrong_passed_ids() {
+        final EntityRepository<I, E, S> repo = repository();
+
+        final int count = 10;
+        final List<E> entities = entities(count);
+        for (E entity : entities) {
+            repo.store(entity);
+        }
+        final List<I> ids = new LinkedList<>();
+        for (int i = 0; i < count; i++) {
+            ids.add(entities.get(i)
+                            .getId());
+        }
+        final Entity<I, S> sideEntity = entity();
+        ids.add(sideEntity.getId());
+
+        final Collection<E> found = repo.loadAll(ids);
+        assertSize(ids.size() - 1, found); // Check we've found all existing items
+
+        for (E entity : found) {
+            assertContains(entity, entities);
+        }
+    }
+
+    @SuppressWarnings("MethodWithMultipleLoops")
+    @Test
+    public void retrieve_all_records_with_entity_filters_and_field_mask_applied() {
+        final EntityRepository<I, E, S> repo = repository();
+
+        final int count = 10;
+        final List<E> entities = entities(count);
+        for (E entity : entities) {
+            repo.store(entity);
+        }
+        final List<EntityId> ids = new LinkedList<>();
+
+        // Find some of the records (half of them in this case)
+        for (int i = 0; i < count / 2; i++) {
+            final EntityId id = EntityId.newBuilder()
+                                        .setId(AnyPacker.pack((Message) entities.get(i)
+                                                                                .getId()))
+                                        .build();
+            ids.add(id);
+        }
+
+        final EntityIdFilter filter = EntityIdFilter.newBuilder()
+                                                    .addAllIds(ids)
+                                                    .build();
+        final EntityFilters filters = EntityFilters.newBuilder()
+                                                   .setIdFilter(filter)
+                                                   .build();
+        final String firstFieldName = entities.get(0)
+                                              .getState()
+                                              .getDescriptorForType()
+                                              .getFields()
+                                              .get(0)
+                                              .getFullName();
+        final FieldMask firstFieldOnly = FieldMask.newBuilder()
+                                                  .addPaths(firstFieldName)
+                                                  .build();
+        final Iterable<E> readEntities = repo.find(filters, firstFieldOnly);
+
+        assertSize(ids.size(), readEntities);
+
+        for (E entity : readEntities) {
+            assertMatches(entity, firstFieldOnly);
+        }
+    }
+
+    private static <E extends Entity<?, ?>> void assertMatches(E entity, FieldMask fieldMask) {
+        final Message state = entity.getState();
+        Tests.assertMatchesMask(state, fieldMask);
+    }
+
+    protected abstract EntityRepository<I, E, S> repository();
+
+    protected abstract E entity();
+
+    protected abstract List<E> entities(int count);
+}
diff --git a/server/src/test/java/org/spine3/server/entity/FieldMasksShould.java b/server/src/test/java/org/spine3/server/entity/FieldMasksShould.java
new file mode 100644
index 00000000000..429f4fabe91
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/entity/FieldMasksShould.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.entity;
+
+import com.google.protobuf.Descriptors;
+import com.google.protobuf.FieldMask;
+import org.junit.Test;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.test.aggregate.Project;
+import org.spine3.test.aggregate.ProjectId;
+import org.spine3.test.aggregate.Task;
+import org.spine3.test.aggregate.TaskId;
+import org.spine3.test.commandservice.customer.Customer;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+import static org.spine3.test.Tests.assertMatchesMask;
+import static org.spine3.test.Tests.hasPrivateUtilityConstructor;
+import static org.spine3.test.Verify.assertSize;
+
+/**
+ * @author Dmytro Dashenkov
+ */
+public class FieldMasksShould {
+
+    @Test
+    public void have_private_constructor() {
+        assertTrue(hasPrivateUtilityConstructor(FieldMasks.class));
+    }
+
+    @Test
+    public void apply_mask_to_single_message() {
+        final FieldMask fieldMask = Given.fieldMask(Project.ID_FIELD_NUMBER, Project.NAME_FIELD_NUMBER);
+        final Project original = Given.newProject("some-string-id");
+
+        final Project masked = FieldMasks.applyMask(fieldMask, original, Given.TYPE);
+
+        assertNotEquals(original, masked);
+        assertMatchesMask(masked, fieldMask);
+    }
+
+    @SuppressWarnings({"MethodWithMultipleLoops", "ObjectEquality"})
+    @Test
+    public void apply_mask_to_message_collections() {
+        final FieldMask fieldMask = Given.fieldMask(Project.STATUS_FIELD_NUMBER, Project.TASK_FIELD_NUMBER);
+        final int count = 5;
+
+        final Collection<Project> original = new LinkedList<>();
+
+        for (int i = 0; i < count; i++) {
+            final Project project = Given.newProject(String.format("project-%s", i));
+            original.add(project);
+        }
+
+        final Collection<Project> masked = FieldMasks.applyMask(fieldMask, original, Given.TYPE);
+
+        assertSize(original.size(), masked);
+
+        // Collection references are not the same
+        assertFalse(original == masked);
+
+        for (Project project : masked) {
+            assertMatchesMask(project, fieldMask);
+
+            // Can't check repeated fields with assertMatchesMask
+            assertFalse(project.getTaskList()
+                               .isEmpty());
+        }
+    }
+
+    @Test
+    public void apply_only_non_empty_mask_to_single_item() {
+        final FieldMask emptyMask = Given.fieldMask();
+
+        final Project origin = Given.newProject("read_whole_message");
+        final Project clone = Project.newBuilder(origin)
+                                     .build();
+
+        final Project processed = FieldMasks.applyMask(emptyMask, origin, Given.TYPE);
+
+        // Check object itself was returned
+        assertTrue(processed == origin);
+
+        // Check object was not changed
+        assertTrue(processed.equals(clone));
+    }
+
+    @SuppressWarnings({"ObjectEquality", "MethodWithMultipleLoops"})
+    @Test
+    public void apply_only_non_empty_mask_to_collection() {
+        final FieldMask emptyMask = Given.fieldMask();
+
+        final Collection<Project> original = new LinkedList<>();
+        final int count = 5;
+
+        for (int i = 0; i < count; i++) {
+            final Project project = Given.newProject(String.format("test-data--%s", i));
+            original.add(project);
+        }
+
+        final Collection<Project> processed = FieldMasks.applyMask(emptyMask, original, Given.TYPE);
+
+        assertSize(original.size(), processed);
+
+        // The argument is not returned
+        assertFalse(original == processed);
+
+        // A copy of the argument is returned (Collection type may differ)
+        final Iterator<Project> processedProjects = processed.iterator();
+
+        for (Project anOriginal : original) {
+            assertTrue(processedProjects.next()
+                                        .equals(anOriginal));
+        }
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void fail_to_mask_message_if_passed_type_does_not_match() {
+        final FieldMask mask = Given.fieldMask(Project.ID_FIELD_NUMBER);
+
+        final Project origin = Given.newProject("some-string");
+
+        FieldMasks.applyMask(mask, origin, Given.OTHER_TYPE);
+    }
+
+    private static class Given {
+
+        private static final TypeUrl TYPE = TypeUrl.of(Project.class);
+        private static final TypeUrl OTHER_TYPE = TypeUrl.of(Customer.class);
+
+        private static Project newProject(String id) {
+            final ProjectId projectId = ProjectId.newBuilder()
+                                                 .setId(id)
+                                                 .build();
+            final Task first = Task.newBuilder()
+                                   .setTaskId(TaskId.newBuilder()
+                                                    .setId(1)
+                                                    .build())
+                                   .setTitle("First Task")
+                                   .build();
+
+            final Task second = Task.newBuilder()
+                                    .setTaskId(TaskId.newBuilder()
+                                                     .setId(2)
+                                                     .build())
+                                    .setTitle("Second Task")
+                                    .build();
+
+            final Project project = Project.newBuilder()
+                                           .setId(projectId)
+                                           .setName(String.format("Test project : %s", id))
+                                           .addTask(first)
+                                           .addTask(second)
+                                           .setStatus(Project.Status.CREATED)
+                                           .build();
+            return project;
+        }
+
+        private static FieldMask fieldMask(int... fieldIndeces) {
+            final FieldMask.Builder mask = FieldMask.newBuilder();
+            final List<Descriptors.FieldDescriptor> allFields = Project.getDescriptor()
+                                                                       .getFields();
+            for (int i : fieldIndeces) {
+                mask.addPaths(allFields.get(i - 1)
+                                       .getFullName());
+            }
+            return mask.build();
+        }
+    }
+}
diff --git a/server/src/test/java/org/spine3/server/entity/RepositoryShould.java b/server/src/test/java/org/spine3/server/entity/RepositoryShould.java
index 8e8d591d4ed..3bd3661c0d8 100644
--- a/server/src/test/java/org/spine3/server/entity/RepositoryShould.java
+++ b/server/src/test/java/org/spine3/server/entity/RepositoryShould.java
@@ -23,7 +23,7 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.spine3.server.BoundedContext;
-import org.spine3.server.storage.EntityStorage;
+import org.spine3.server.storage.RecordStorage;
 import org.spine3.server.storage.Storage;
 import org.spine3.server.storage.StorageFactory;
 import org.spine3.server.storage.memory.InMemoryStorageFactory;
@@ -195,7 +195,7 @@ protected ProjectEntity load(ProjectId id) {
 
         @Override
         protected Storage createStorage(StorageFactory factory) {
-            return factory.createEntityStorage(getEntityClass());
+            return factory.createRecordStorage(getEntityClass());
         }
     }
 
@@ -227,7 +227,7 @@ public void allow_initializing_storage_only_once() {
     public void close_storage_on_close() throws Exception {
         repository.initStorage(storageFactory);
 
-        final EntityStorage<?> storage = (EntityStorage<?>) repository.getStorage();
+        final RecordStorage<?> storage = (RecordStorage<?>) repository.getStorage();
         repository.close();
 
         //noinspection ConstantConditions
diff --git a/server/src/test/java/org/spine3/server/procman/ProcessManagerRepositoryShould.java b/server/src/test/java/org/spine3/server/procman/ProcessManagerRepositoryShould.java
index 0e803b066cf..e41f73b4422 100644
--- a/server/src/test/java/org/spine3/server/procman/ProcessManagerRepositoryShould.java
+++ b/server/src/test/java/org/spine3/server/procman/ProcessManagerRepositoryShould.java
@@ -38,6 +38,8 @@
 import org.spine3.server.BoundedContext;
 import org.spine3.server.command.Assign;
 import org.spine3.server.command.CommandDispatcher;
+import org.spine3.server.entity.AbstractEntityRepositoryShould;
+import org.spine3.server.entity.EntityRepository;
 import org.spine3.server.entity.IdFunction;
 import org.spine3.server.event.EventBus;
 import org.spine3.server.event.GetProducerIdFromEvent;
@@ -59,6 +61,8 @@
 
 import javax.annotation.Nonnull;
 import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Set;
 
 import static org.junit.Assert.assertEquals;
@@ -74,7 +78,8 @@
  * @author Alexander Litus
  */
 @SuppressWarnings("InstanceMethodNamingConvention")
-public class ProcessManagerRepositoryShould {
+public class ProcessManagerRepositoryShould
+        extends AbstractEntityRepositoryShould<ProcessManagerRepositoryShould.TestProcessManager, ProjectId, Project> {
 
     private static final ProjectId ID = Given.AggregateId.newProjectId();
 
@@ -89,18 +94,19 @@ public void setUp() {
         eventBus = spy(TestEventBusFactory.create());
         boundedContext = TestBoundedContextFactory.newBoundedContext(eventBus);
 
-        boundedContext.getCommandBus().register(new CommandDispatcher() {
-            @Override
-            public Set<CommandClass> getCommandClasses() {
-                return CommandClass.setOf(AddTask.class);
-            }
+        boundedContext.getCommandBus()
+                      .register(new CommandDispatcher() {
+                          @Override
+                          public Set<CommandClass> getCommandClasses() {
+                              return CommandClass.setOf(AddTask.class);
+                          }
 
-            @Override
-            public void dispatch(Command request) throws Exception {
-                // Simply swallow the command. We need this dispatcher for allowing Process Manager
-                // under test to route the AddTask command.
-            }
-        });
+                          @Override
+                          public void dispatch(Command request) throws Exception {
+                              // Simply swallow the command. We need this dispatcher for allowing Process Manager
+                              // under test to route the AddTask command.
+                          }
+                      });
 
         repository = new TestProcessManagerRepository(boundedContext);
         repository.initStorage(InMemoryStorageFactory.getInstance());
@@ -205,6 +211,36 @@ public void return_event_classes() {
         assertTrue(eventClasses.contains(EventClass.of(ProjectStarted.class)));
     }
 
+    @Override
+    protected EntityRepository<ProjectId, TestProcessManager, Project> repository() {
+        final TestProcessManagerRepository repo = new TestProcessManagerRepository(
+                TestBoundedContextFactory.newBoundedContext());
+        repo.initStorage(InMemoryStorageFactory.getInstance());
+        return repo;
+    }
+
+    @Override
+    protected TestProcessManager entity() {
+        final ProjectId id = ProjectId.newBuilder()
+                                      .setId("123-id")
+                                      .build();
+        return new TestProcessManager(id);
+    }
+
+    @Override
+    protected List<TestProcessManager> entities(int count) {
+        final List<TestProcessManager> procmans = new ArrayList<>(count);
+
+        for (int i = 0; i < count; i++) {
+            final ProjectId id = ProjectId.newBuilder()
+                                          .setId(String.format("procman-number-%s", i))
+                                          .build();
+
+            procmans.add(new TestProcessManager(id));
+        }
+        return procmans;
+    }
+
     private static class TestProcessManagerRepository
             extends ProcessManagerRepository<ProjectId, TestProcessManager, Project> {
 
@@ -218,13 +254,16 @@ private TestProcessManagerRepository(BoundedContext boundedContext) {
         }
     }
 
-    private static class TestProcessManager extends ProcessManager<ProjectId, Project> {
+    /* package */ static class TestProcessManager extends ProcessManager<ProjectId, Project> {
 
         /** The event message we store for inspecting in delivery tests. */
         private static final Multimap<ProjectId, Message> messagesDelivered = HashMultimap.create();
 
-        @SuppressWarnings("PublicConstructorInNonPublicClass") /* A Process Manager constructor must be public by
-                convention. It is used by reflection and is part of public API of process managers. */
+        @SuppressWarnings(
+                {"PublicConstructorInNonPublicClass",           /* A Process Manager constructor must be public
+                                                                 * by convention. It is used by reflection
+                                                                 * and is part of public API of process managers. */
+                        "WeakerAccess"})
         public TestProcessManager(ProjectId id) {
             super(id);
         }
@@ -233,12 +272,13 @@ private void keep(Message commandOrEventMsg) {
             messagesDelivered.put(getState().getId(), commandOrEventMsg);
         }
 
-        /* package */ static boolean processed(Message eventMessage) {
+        private static boolean processed(Message eventMessage) {
             final boolean result = messagesDelivered.containsValue(eventMessage);
             return result;
         }
 
-        /* package */ static void clearMessageDeliveryHistory() {
+        /* package */
+        static void clearMessageDeliveryHistory() {
             messagesDelivered.clear();
         }
 
@@ -296,6 +336,8 @@ private void handleProjectStarted() {
             incrementState(newState);
         }
 
+        @SuppressWarnings("UnusedParameters") /* The parameter left to show that a command subscriber
+                                                 can have two parameters. */
         @Assign
         public ProjectCreated handle(CreateProject command, CommandContext ignored) {
             keep(command);
@@ -304,6 +346,8 @@ public ProjectCreated handle(CreateProject command, CommandContext ignored) {
             return Given.EventMessage.projectCreated(command.getProjectId());
         }
 
+        @SuppressWarnings("UnusedParameters") /* The parameter left to show that a command subscriber
+                                                 can have two parameters. */
         @Assign
         public TaskAdded handle(AddTask command, CommandContext ignored) {
             keep(command);
@@ -320,8 +364,8 @@ public CommandRouted handle(StartProject command, CommandContext context) {
             final Message addTask = Given.CommandMessage.addTask(command.getProjectId());
 
             return newRouter().of(command, context)
-                    .add(addTask)
-                    .route();
+                              .add(addTask)
+                              .route();
         }
     }
 }
diff --git a/server/src/test/java/org/spine3/server/projection/ProjectionRepositoryShould.java b/server/src/test/java/org/spine3/server/projection/ProjectionRepositoryShould.java
index e98f67dc3b6..f094b4bcf19 100644
--- a/server/src/test/java/org/spine3/server/projection/ProjectionRepositoryShould.java
+++ b/server/src/test/java/org/spine3/server/projection/ProjectionRepositoryShould.java
@@ -30,9 +30,11 @@
 import org.spine3.base.EventContext;
 import org.spine3.base.Events;
 import org.spine3.server.BoundedContext;
+import org.spine3.server.entity.AbstractEntityRepositoryShould;
+import org.spine3.server.entity.EntityRepository;
 import org.spine3.server.event.EventStore;
 import org.spine3.server.event.Subscribe;
-import org.spine3.server.storage.EntityStorage;
+import org.spine3.server.storage.RecordStorage;
 import org.spine3.server.storage.memory.InMemoryStorageFactory;
 import org.spine3.server.type.EventClass;
 import org.spine3.test.projection.Project;
@@ -41,6 +43,8 @@
 import org.spine3.test.projection.event.ProjectStarted;
 import org.spine3.test.projection.event.TaskAdded;
 
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Set;
 
 import static org.junit.Assert.assertEquals;
@@ -59,7 +63,8 @@
  * @author Alexander Litus
  */
 @SuppressWarnings("InstanceMethodNamingConvention")
-public class ProjectionRepositoryShould {
+public class ProjectionRepositoryShould
+        extends AbstractEntityRepositoryShould<ProjectionRepositoryShould.TestProjection, ProjectId, Project> {
 
     private static final ProjectId ID = Given.AggregateId.newProjectId();
 
@@ -145,8 +150,8 @@ public void return_id_from_event_message() {
 
     @Test
     public void return_entity_storage() {
-        final EntityStorage<ProjectId> entityStorage = repository.entityStorage();
-        assertNotNull(entityStorage);
+        final RecordStorage<ProjectId> recordStorage = repository.recordStorage();
+        assertNotNull(recordStorage);
     }
 
     @Test
@@ -207,8 +212,37 @@ public void catches_up_from_EventStorage() {
         assertTrue(TestProjection.processed(Events.getMessage(projectStartedEvent)));
     }
 
+    @Override
+    protected EntityRepository<ProjectId, TestProjection, Project> repository() {
+        return repository;
+    }
+
+    @Override
+    protected TestProjection entity() {
+        final TestProjection projection = new TestProjection(ProjectId.newBuilder()
+                                                                      .setId("single-test-projection")
+                                                                      .build());
+        return projection;
+    }
+
+    @Override
+    protected List<TestProjection> entities(int count) {
+        final List<TestProjection> projections = new LinkedList<>();
+
+        for (int i = 0; i < count; i++) {
+            final TestProjection projection = new TestProjection(
+                    ProjectId.newBuilder()
+                             .setId(String.format("test-projection-%s", i))
+                             .build());
+
+            projections.add(projection);
+        }
+
+        return projections;
+    }
+
     /** The projection stub used in tests. */
-    private static class TestProjection extends Projection<ProjectId, Project> {
+    /* package */ static class TestProjection extends Projection<ProjectId, Project> {
 
         /** The event message history we store for inspecting in delivery tests. */
         private static final Multimap<ProjectId, Message> eventMessagesDelivered = HashMultimap.create();
@@ -221,12 +255,14 @@ private void keep(Message eventMessage) {
             eventMessagesDelivered.put(getState().getId(), eventMessage);
         }
 
-        /* package */ static boolean processed(Message eventMessage) {
+        /* package */
+        static boolean processed(Message eventMessage) {
             final boolean result = eventMessagesDelivered.containsValue(eventMessage);
             return result;
         }
 
-        /* package */ static void clearMessageDeliveryHistory() {
+        /* package */
+        static void clearMessageDeliveryHistory() {
             eventMessagesDelivered.clear();
         }
 
@@ -253,7 +289,7 @@ public void on(TaskAdded event) {
 
         /* EventContext parameter left to show that a projection subscriber can have two parameters. */
         @Subscribe
-        public void on(ProjectStarted event, EventContext ignored) {
+        public void on(ProjectStarted event, @SuppressWarnings("UnusedParameters") EventContext ignored) {
             keep(event);
             final Project newState = getState().toBuilder()
                                                .setStatus(Project.Status.STARTED)
diff --git a/server/src/test/java/org/spine3/server/stand/Given.java b/server/src/test/java/org/spine3/server/stand/Given.java
new file mode 100644
index 00000000000..0dcbd1ba614
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/stand/Given.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.stand;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import com.google.protobuf.Message;
+import org.spine3.base.Command;
+import org.spine3.base.CommandContext;
+import org.spine3.base.Event;
+import org.spine3.base.EventContext;
+import org.spine3.base.EventId;
+import org.spine3.base.Identifiers;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.BoundedContext;
+import org.spine3.server.aggregate.Aggregate;
+import org.spine3.server.aggregate.AggregateRepository;
+import org.spine3.server.aggregate.Apply;
+import org.spine3.server.command.Assign;
+import org.spine3.server.event.Subscribe;
+import org.spine3.server.projection.Projection;
+import org.spine3.server.projection.ProjectionRepository;
+import org.spine3.server.storage.memory.InMemoryStorageFactory;
+import org.spine3.test.projection.Project;
+import org.spine3.test.projection.ProjectId;
+import org.spine3.test.projection.command.CreateProject;
+import org.spine3.test.projection.event.ProjectCreated;
+
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+/**
+ * @author Dmytro Dashenkov
+ */
+/*package*/ class Given {
+
+    /*package*/ static final int THREADS_COUNT_IN_POOL_EXECUTOR = 10;
+    /*package*/ static final int SEVERAL = THREADS_COUNT_IN_POOL_EXECUTOR;
+
+    private static final String PROJECT_UUID = Identifiers.newUuid();
+    /*package*/ static final int AWAIT_SECONDS = 6;
+
+    private Given() {
+    }
+
+    /*package*/ static class StandTestProjectionRepository extends ProjectionRepository<ProjectId, StandTestProjection, Project> {
+        /*package*/ StandTestProjectionRepository(BoundedContext boundedContext) {
+            super(boundedContext);
+        }
+
+        @Override
+        protected ProjectId getEntityId(Message event, EventContext context) {
+            return ProjectId.newBuilder().setId(PROJECT_UUID).build();
+        }
+    }
+
+    /*package*/ static class StandTestAggregateRepository extends AggregateRepository<ProjectId, StandTestAggregate> {
+
+        /**
+         * Creates a new repository instance.
+         *
+         * @param boundedContext the bounded context to which this repository belongs
+         */
+        /*package*/ StandTestAggregateRepository(BoundedContext boundedContext) {
+            super(boundedContext);
+        }
+    }
+
+    private static class StandTestAggregate extends Aggregate<ProjectId, Any, Any.Builder> {
+
+        /**
+         * Creates a new aggregate instance.
+         *
+         * @param id the ID for the new aggregate
+         * @throws IllegalArgumentException if the ID is not of one of the supported types
+         */
+        public StandTestAggregate(ProjectId id) {
+            super(id);
+        }
+
+        @Assign
+        public List<? extends Event> handle(CreateProject createProject, CommandContext context) {
+            return null;
+        }
+
+        @Apply
+        public void handle(ProjectCreated event) {
+            // Do nothing
+        }
+    }
+
+    /*package*/ static class StandTestProjection extends Projection<ProjectId, Project> {
+        /**
+         * Creates a new instance.
+         *
+         * Required to be public.
+         *
+         * @param id the ID for the new instance
+         * @throws IllegalArgumentException if the ID is not of one of the supported types
+         */
+        public StandTestProjection(ProjectId id) {
+            super(id);
+        }
+
+        @Subscribe
+        public void handle(ProjectCreated event, EventContext context) {
+            // Do nothing
+        }
+    }
+
+    /*package*/ static Event validEvent() {
+        return Event.newBuilder()
+                    .setMessage(AnyPacker.pack(ProjectCreated.newBuilder()
+                                                             .setProjectId(ProjectId.newBuilder().setId("12345AD0"))
+                                                             .build())
+                                         .toBuilder()
+                                         .setTypeUrl(TypeUrl.SPINE_TYPE_URL_PREFIX + "/" + ProjectCreated.getDescriptor().getFullName())
+                                         .build())
+                    .setContext(EventContext.newBuilder()
+                                            .setDoNotEnrich(true)
+                                            .setCommandContext(CommandContext.getDefaultInstance())
+                                            .setEventId(EventId.newBuilder()
+                                                               .setUuid(Identifiers.newUuid())
+                                                               .build()))
+                    .build();
+    }
+
+    /*package*/ static Command validCommand() {
+        return Command.newBuilder()
+                      .setMessage(AnyPacker.pack(CreateProject.getDefaultInstance()))
+                      .setContext(CommandContext.getDefaultInstance())
+                      .build();
+    }
+
+    /*package*/ static ProjectionRepository<?, ?, ?> projectionRepo(BoundedContext context) {
+        return new StandTestProjectionRepository(context);
+    }
+
+    /*package*/ static AggregateRepository<?, ?> aggregateRepo(BoundedContext context) {
+        return new StandTestAggregateRepository(context);
+    }
+
+    /*package*/ static BoundedContext boundedContext(Stand stand, int concurrentThreads) {
+        final Executor executor = concurrentThreads > 0 ? Executors.newFixedThreadPool(concurrentThreads) :
+                                  MoreExecutors.directExecutor();
+
+        return boundedContextBuilder(stand)
+                             .setStandFunnelExecutor(executor)
+                             .build();
+    }
+
+    /*package*/ static BoundedContext boundedContext(Stand stand, Executor standFunnelExecutor) {
+        return boundedContextBuilder(stand)
+                .setStandFunnelExecutor(standFunnelExecutor)
+                .build();
+    }
+
+    private static BoundedContext.Builder boundedContextBuilder(Stand stand) {
+        return BoundedContext.newBuilder()
+                             .setStand(stand)
+                             .setStorageFactory(InMemoryStorageFactory.getInstance());
+    }
+}
diff --git a/server/src/test/java/org/spine3/server/stand/StandFunnelShould.java b/server/src/test/java/org/spine3/server/stand/StandFunnelShould.java
new file mode 100644
index 00000000000..9aee7a378eb
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/stand/StandFunnelShould.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import io.netty.util.internal.ConcurrentSet;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.ArgumentMatchers;
+import org.spine3.server.BoundedContext;
+import org.spine3.server.aggregate.AggregateRepository;
+import org.spine3.server.projection.ProjectionRepository;
+import org.spine3.server.storage.memory.InMemoryStorageFactory;
+import org.spine3.testdata.TestStandFactory;
+
+import java.security.SecureRandom;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+/**
+ * @author Alex Tymchenko
+ * @author Dmytro Dashenkov
+ */
+public class StandFunnelShould {
+
+    // **** Positive scenarios (unit) ****
+
+    @Test
+    public void initialize_properly_with_stand_only() {
+        final Stand stand = TestStandFactory.create();
+        final StandFunnel.Builder builder = StandFunnel.newBuilder()
+                                                       .setStand(stand);
+        final StandFunnel standFunnel = builder.build();
+        Assert.assertNotNull(standFunnel);
+    }
+
+    @Test
+    public void initialize_properly_with_all_builder_options() {
+        final Stand stand = TestStandFactory.create();
+        final Executor executor = Executors.newSingleThreadExecutor();
+
+        final StandFunnel funnel = StandFunnel.newBuilder()
+                                                      .setStand(stand)
+                                                      .setExecutor(executor)
+                                                      .build();
+        Assert.assertNotNull(funnel);
+    }
+
+    @Test
+    public void initialize_properly_with_no_executor() {
+        final Stand stand = TestStandFactory.create();
+
+        final StandFunnel funnelForBusyStand = StandFunnel.newBuilder()
+                                                          .setStand(stand)
+                                                          .build();
+        Assert.assertNotNull(funnelForBusyStand);
+    }
+
+    @Test
+    public void deliver_mock_updates_to_stand() {
+        final Object id = new Object();
+        final Any state = Any.getDefaultInstance();
+
+        final Stand stand = mock(Stand.class);
+        doNothing().when(stand).update(id, state);
+
+        final StandFunnel funnel = StandFunnel.newBuilder()
+                                              .setStand(stand)
+                                              .build();
+
+        funnel.post(id, state);
+
+        verify(stand).update(id, state);
+    }
+
+
+    @Test
+    public void use_executor_from_builder() {
+        final Stand stand = spy(TestStandFactory.create());
+        final Executor executor = spy(new Executor() {
+            @Override
+            public void execute(Runnable command) {
+
+            }
+        });
+        final StandFunnel.Builder builder = StandFunnel.newBuilder()
+                                                       .setStand(stand)
+                                                       .setExecutor(executor);
+
+        final StandFunnel standFunnel = builder.build();
+        Assert.assertNotNull(standFunnel);
+
+        final Any someState = Any.getDefaultInstance();
+        final Object someId = new Object();
+        standFunnel.post(someId, someState);
+
+        verify(executor).execute(any(Runnable.class));
+    }
+
+
+    // **** Negative scenarios (unit) ****
+
+    @SuppressWarnings("ResultOfMethodCallIgnored")
+    @Test(expected = NullPointerException.class)
+    public void fail_to_initialize_with_improper_stand() {
+        @SuppressWarnings("ConstantConditions") // null is marked as improper with this warning
+        final StandFunnel.Builder builder = StandFunnel.newBuilder().setStand(null);
+
+        builder.build();
+    }
+
+    @SuppressWarnings("ResultOfMethodCallIgnored")
+    @Test(expected = IllegalStateException.class)
+    public void fail_to_initialize_from_empty_builder() {
+        final StandFunnel.Builder builder = StandFunnel.newBuilder();
+        builder.build();
+    }
+
+    // **** Integration scenarios (<source> -> StandFunnel -> Mock Stand) ****
+
+    @Test
+    public void deliver_updates_from_projection_repository() {
+        checkUpdatesDelivery(false, projectionRepositoryDispatch());
+    }
+
+    @Test
+    public void deliver_updates_form_aggregate_repository() {
+        checkUpdatesDelivery(false, aggregateRepositoryDispatch());
+    }
+
+    @Test
+    public void deliver_updates_from_several_repositories_in_single_thread() {
+        checkUpdatesDelivery(false, getSeveralRepositoryDispatchCalls());
+    }
+
+    @Test
+    public void deliver_updates_from_several_repositories_in_multiple_threads() {
+        checkUpdatesDelivery(true, getSeveralRepositoryDispatchCalls());
+    }
+
+    private static BoundedContextAction[] getSeveralRepositoryDispatchCalls() {
+        final BoundedContextAction[] result = new BoundedContextAction[Given.SEVERAL];
+        final Random random = new SecureRandom();
+
+        for (int i = 0; i < result.length; i++) {
+            result[i] = (i % 2 == 0) ? aggregateRepositoryDispatch() : projectionRepositoryDispatch();
+        }
+
+        return result;
+    }
+
+    private static void checkUpdatesDelivery(boolean isConcurrent, BoundedContextAction... dispatchActions) {
+        checkNotNull(dispatchActions);
+
+        final Stand stand = mock(Stand.class);
+        final Executor executor = isConcurrent ?
+                                  Executors.newFixedThreadPool(Given.THREADS_COUNT_IN_POOL_EXECUTOR) :
+                                  MoreExecutors.directExecutor();
+
+        final BoundedContext boundedContext = spy(Given.boundedContext(stand, executor));
+
+
+        for (BoundedContextAction dispatchAction : dispatchActions) {
+            dispatchAction.perform(boundedContext);
+        }
+
+        // Was called as many times as there are dispatch actions.
+        verify(boundedContext, times(dispatchActions.length)).getStandFunnel();
+
+        if (isConcurrent) {
+            try {
+                ((ExecutorService) executor).awaitTermination(Given.SEVERAL, TimeUnit.SECONDS);
+            } catch (InterruptedException ignored) {
+            }
+        }
+
+        verify(stand, times(dispatchActions.length)).update(ArgumentMatchers.any(), any(Any.class));
+    }
+
+    private static BoundedContextAction aggregateRepositoryDispatch() {
+        return new BoundedContextAction() {
+            @Override
+            public void perform(BoundedContext context) {
+                // Init repository
+                final AggregateRepository<?, ?> repository = Given.aggregateRepo(context);
+
+                repository.initStorage(InMemoryStorageFactory.getInstance());
+
+                try {
+                    // Mock aggregate and mock stand are not able to handle events returned after command handling.
+                    // This causes IllegalStateException to be thrown.
+                    // Note that this is not the end of a test case, so we can't just "expect=IllegalStateException"
+                    repository.dispatch(Given.validCommand());
+                } catch (IllegalStateException e) {
+                    // Handle null event dispatching after the command is handled.
+
+                    // Check if this error is caused by returning nuu or empty list after command processing.
+                    // Proceed crash if it's not
+                    if (!e.getMessage()
+                          .contains("No record found for command ID: EMPTY")) {
+                        throw e;
+                    }
+                }
+            }
+        };
+    }
+
+    private static BoundedContextAction projectionRepositoryDispatch() {
+        return new BoundedContextAction() {
+            @Override
+            public void perform(BoundedContext context) {
+                // Init repository
+                final ProjectionRepository repository = Given.projectionRepo(context);
+
+                repository.initStorage(InMemoryStorageFactory.getInstance());
+                repository.setOnline();
+
+                // Dispatch an update from projection repo
+                repository.dispatch(Given.validEvent());
+            }
+        };
+    }
+
+
+    @SuppressWarnings("MethodWithMultipleLoops")
+    @Test
+    public void deliver_updates_through_several_threads() throws InterruptedException {
+        final int threadsCount = Given.THREADS_COUNT_IN_POOL_EXECUTOR;
+        @SuppressWarnings("LocalVariableNamingConvention") // Too long variable name
+        final int threadExecutionMaxAwaitSeconds = Given.AWAIT_SECONDS;
+
+        final Set<String> threadInvocationRegistry = new ConcurrentSet<>();
+
+        final Stand stand = mock(Stand.class);
+        doNothing().when(stand).update(ArgumentMatchers.any(), any(Any.class));
+
+        final StandFunnel standFunnel = StandFunnel.newBuilder()
+                                                   .setStand(stand)
+                                                   .build();
+
+        final ExecutorService executor = Executors.newFixedThreadPool(threadsCount);
+
+
+        final Runnable task = new Runnable() {
+            @Override
+            public void run() {
+                final String threadName = Thread.currentThread().getName();
+                Assert.assertFalse(threadInvocationRegistry.contains(threadName));
+
+                standFunnel.post(new Object(), Any.getDefaultInstance());
+
+                threadInvocationRegistry.add(threadName);
+            }
+        };
+
+        for (int i = 0; i < threadsCount; i++) {
+            executor.execute(task);
+        }
+
+        executor.awaitTermination(threadExecutionMaxAwaitSeconds, TimeUnit.SECONDS);
+
+        Assert.assertEquals(threadInvocationRegistry.size(), threadsCount);
+
+    }
+
+    private interface BoundedContextAction {
+        void perform(BoundedContext context);
+    }
+
+}
diff --git a/server/src/test/java/org/spine3/server/stand/StandShould.java b/server/src/test/java/org/spine3/server/stand/StandShould.java
new file mode 100644
index 00000000000..297629768ef
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/stand/StandShould.java
@@ -0,0 +1,1142 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.stand;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import com.google.protobuf.Any;
+import com.google.protobuf.Descriptors;
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.Message;
+import io.grpc.stub.StreamObserver;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.ArgumentMatchers;
+import org.spine3.base.Queries;
+import org.spine3.base.Responses;
+import org.spine3.client.EntityFilters;
+import org.spine3.client.EntityId;
+import org.spine3.client.Query;
+import org.spine3.client.QueryResponse;
+import org.spine3.client.Subscription;
+import org.spine3.client.Target;
+import org.spine3.people.PersonName;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.BoundedContext;
+import org.spine3.server.Given.CustomerAggregate;
+import org.spine3.server.Given.CustomerAggregateRepository;
+import org.spine3.server.projection.ProjectionRepository;
+import org.spine3.server.stand.Given.StandTestProjectionRepository;
+import org.spine3.server.storage.EntityStorageRecord;
+import org.spine3.server.storage.StandStorage;
+import org.spine3.server.storage.memory.InMemoryStandStorage;
+import org.spine3.test.commandservice.customer.Customer;
+import org.spine3.test.commandservice.customer.CustomerId;
+import org.spine3.test.projection.Project;
+import org.spine3.test.projection.ProjectId;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Random;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.Executor;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Maps.newHashMap;
+import static com.google.common.collect.Sets.newHashSet;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.spine3.server.stand.Given.StandTestProjection;
+import static org.spine3.test.Verify.assertSize;
+import static org.spine3.testdata.TestBoundedContextFactory.newBoundedContext;
+
+/**
+ * @author Alex Tymchenko
+ * @author Dmytro Dashenkov
+ */
+//It's OK for a test.
+@SuppressWarnings({"OverlyCoupledClass", "InstanceMethodNamingConvention", "ClassWithTooManyMethods"})
+public class StandShould {
+    private static final int TOTAL_CUSTOMERS_FOR_BATCH_READING = 10;
+    private static final int TOTAL_PROJECTS_FOR_BATCH_READING = 10;
+
+    @Test
+    public void initialize_with_empty_builder() {
+        final Stand.Builder builder = Stand.newBuilder();
+        final Stand stand = builder.build();
+
+        assertNotNull(stand);
+        assertTrue("Exposed types must be empty after the initialization.", stand.getExposedTypes()
+                                                                                 .isEmpty());
+        assertTrue("Exposed aggregate types must be empty after the initialization", stand.getExposedAggregateTypes()
+                                                                                          .isEmpty());
+    }
+
+    @Test
+    public void register_projection_repositories() {
+        final Stand stand = Stand.newBuilder()
+                                 .build();
+        final BoundedContext boundedContext = newBoundedContext(stand);
+
+        checkTypesEmpty(stand);
+
+        final StandTestProjectionRepository standTestProjectionRepo = new StandTestProjectionRepository(boundedContext);
+        stand.registerTypeSupplier(standTestProjectionRepo);
+        checkHasExactlyOne(stand.getExposedTypes(), Project.getDescriptor());
+
+        final ImmutableSet<TypeUrl> knownAggregateTypes = stand.getExposedAggregateTypes();
+        // As we registered a projection repo, known aggregate types should be still empty.
+        assertTrue("For some reason an aggregate type was registered", knownAggregateTypes.isEmpty());
+
+        final StandTestProjectionRepository anotherTestProjectionRepo = new StandTestProjectionRepository(boundedContext);
+        stand.registerTypeSupplier(anotherTestProjectionRepo);
+        checkHasExactlyOne(stand.getExposedTypes(), Project.getDescriptor());
+    }
+
+    @Test
+    public void register_aggregate_repositories() {
+        final Stand stand = Stand.newBuilder()
+                                 .build();
+        final BoundedContext boundedContext = newBoundedContext(stand);
+
+        checkTypesEmpty(stand);
+
+        final CustomerAggregateRepository customerAggregateRepo = new CustomerAggregateRepository(boundedContext);
+        stand.registerTypeSupplier(customerAggregateRepo);
+
+        final Descriptors.Descriptor customerEntityDescriptor = Customer.getDescriptor();
+        checkHasExactlyOne(stand.getExposedTypes(), customerEntityDescriptor);
+        checkHasExactlyOne(stand.getExposedAggregateTypes(), customerEntityDescriptor);
+
+        @SuppressWarnings("LocalVariableNamingConvention")
+        final CustomerAggregateRepository anotherCustomerAggregateRepo = new CustomerAggregateRepository(boundedContext);
+        stand.registerTypeSupplier(anotherCustomerAggregateRepo);
+        checkHasExactlyOne(stand.getExposedTypes(), customerEntityDescriptor);
+        checkHasExactlyOne(stand.getExposedAggregateTypes(), customerEntityDescriptor);
+    }
+
+    @Test
+    public void use_provided_executor_upon_update_of_watched_type() {
+        final Executor executor = mock(Executor.class);
+        final Stand stand = Stand.newBuilder()
+                                 .setCallbackExecutor(executor)
+                                 .build();
+        final BoundedContext boundedContext = newBoundedContext(stand);
+        final StandTestProjectionRepository standTestProjectionRepo = new StandTestProjectionRepository(boundedContext);
+        stand.registerTypeSupplier(standTestProjectionRepo);
+
+        final Target projectProjectionTarget = Queries.Targets.allOf(Project.class);
+        final Subscription subscription = stand.subscribe(projectProjectionTarget);
+        stand.activate(subscription, emptyUpdateCallback());
+        assertNotNull(subscription);
+
+        verify(executor, never()).execute(any(Runnable.class));
+
+        final Any someUpdate = AnyPacker.pack(Project.getDefaultInstance());
+        final Object someId = new Object();
+        stand.update(someId, someUpdate);
+
+        verify(executor, times(1)).execute(any(Runnable.class));
+    }
+
+    @Test
+    public void operate_with_storage_provided_through_builder() {
+        final StandStorage standStorageMock = mock(StandStorage.class);
+        final Stand stand = Stand.newBuilder()
+                                 .setStorage(standStorageMock)
+                                 .build();
+        assertNotNull(stand);
+
+        final BoundedContext boundedContext = newBoundedContext(stand);
+        final CustomerAggregateRepository customerAggregateRepo = new CustomerAggregateRepository(boundedContext);
+        stand.registerTypeSupplier(customerAggregateRepo);
+
+        final int numericIdValue = 17;
+        final CustomerId customerId = customerIdFor(numericIdValue);
+        final CustomerAggregate customerAggregate = customerAggregateRepo.create(customerId);
+        final Customer customerState = customerAggregate.getState();
+        final Any packedState = AnyPacker.pack(customerState);
+        final TypeUrl customerType = TypeUrl.of(Customer.class);
+
+        verify(standStorageMock, never()).write(any(AggregateStateId.class), any(EntityStorageRecord.class));
+
+        stand.update(customerId, packedState);
+
+        final AggregateStateId expectedAggregateStateId = AggregateStateId.of(customerId, customerType);
+        final EntityStorageRecord expectedRecord = EntityStorageRecord.newBuilder()
+                                                                      .setState(packedState)
+                                                                      .build();
+        verify(standStorageMock, times(1)).write(eq(expectedAggregateStateId), recordStateMatcher(expectedRecord));
+    }
+
+    @Test
+    public void return_empty_list_for_aggregate_read_all_on_empty_stand_storage() {
+        final Query readAllCustomers = Queries.readAll(Customer.class);
+        checkEmptyResultForTargetOnEmptyStorage(readAllCustomers);
+    }
+
+    @Test
+    public void return_empty_list_to_unknown_type_reading() {
+
+        final Stand stand = Stand.newBuilder()
+                                 .build();
+
+        checkTypesEmpty(stand);
+
+        // Customer type was NOT registered.
+        // So create a query for an unknown type.
+        final Query readAllCustomers = Queries.readAll(Customer.class);
+
+        final MemoizeQueryResponseObserver responseObserver = new MemoizeQueryResponseObserver();
+        stand.execute(readAllCustomers, responseObserver);
+
+        verifyObserver(responseObserver);
+
+        final List<Any> messageList = checkAndGetMessageList(responseObserver);
+
+        assertTrue("Query returned a non-empty response message list for an unknown type", messageList.isEmpty());
+    }
+
+    @Test
+    public void return_empty_list_for_aggregate_read_by_ids_on_empty_stand_storage() {
+
+        final Query readCustomersById = Queries.readByIds(Customer.class, newHashSet(
+                customerIdFor(1), customerIdFor(2)
+        ));
+
+        checkEmptyResultForTargetOnEmptyStorage(readCustomersById);
+    }
+
+    @Test
+    public void return_empty_list_for_aggregate_reads_with_filters_not_set() {
+
+        final Target noneOfCustomers = Queries.Targets.someOf(Customer.class, Collections.<Message>emptySet());
+        checkEmptyResultOnNonEmptyStorageForQueryTarget(noneOfCustomers);
+    }
+
+    @Test
+    public void return_single_result_for_aggregate_state_read_by_id() {
+        doCheckReadingCustomersById(1);
+    }
+
+    @Test
+    public void return_multiple_results_for_aggregate_state_batch_read_by_ids() {
+        doCheckReadingCustomersById(TOTAL_CUSTOMERS_FOR_BATCH_READING);
+    }
+
+    @Test
+    public void return_single_result_for_projection_read_by_id() {
+        doCheckReadingProjectsById(1);
+    }
+
+    @Test
+    public void return_multiple_results_for_projection_batch_read_by_ids() {
+        doCheckReadingProjectsById(TOTAL_PROJECTS_FOR_BATCH_READING);
+    }
+
+    @Test
+    public void return_multiple_results_for_projection_batch_read_by_ids_with_field_mask() {
+        final List<Descriptors.FieldDescriptor> projectFields = Project.getDescriptor()
+                                                                       .getFields();
+        doCheckReadingCustomersByIdAndFieldMask(
+                projectFields.get(0)
+                             .getFullName(), // ID
+                projectFields.get(1)
+                             .getFullName()); // Name
+    }
+
+    @Test
+    public void trigger_subscription_callback_upon_update_of_aggregate() {
+        final Stand stand = prepareStandWithAggregateRepo(mock(StandStorage.class));
+        final Target allCustomers = Queries.Targets.allOf(Customer.class);
+
+        final MemoizeEntityUpdateCallback memoizeCallback = new MemoizeEntityUpdateCallback();
+        final Subscription subscription = stand.subscribe(allCustomers);
+        stand.activate(subscription, memoizeCallback);
+        assertNotNull(subscription);
+        assertNull(memoizeCallback.newEntityState);
+
+        final Map.Entry<CustomerId, Customer> sampleData = fillSampleCustomers(1).entrySet()
+                                                                                 .iterator()
+                                                                                 .next();
+        final CustomerId customerId = sampleData.getKey();
+        final Customer customer = sampleData.getValue();
+        final Any packedState = AnyPacker.pack(customer);
+        stand.update(customerId, packedState);
+
+        assertEquals(packedState, memoizeCallback.newEntityState);
+    }
+
+    @Test
+    public void trigger_subscription_callback_upon_update_of_projection() {
+        final Stand stand = prepareStandWithAggregateRepo(mock(StandStorage.class));
+        final Target allProjects = Queries.Targets.allOf(Project.class);
+
+        final MemoizeEntityUpdateCallback memoizeCallback = new MemoizeEntityUpdateCallback();
+        final Subscription subscription = stand.subscribe(allProjects);
+        stand.activate(subscription, memoizeCallback);
+        assertNotNull(subscription);
+        assertNull(memoizeCallback.newEntityState);
+
+        final Map.Entry<ProjectId, Project> sampleData = fillSampleProjects(1).entrySet()
+                                                                              .iterator()
+                                                                              .next();
+        final ProjectId projectId = sampleData.getKey();
+        final Project project = sampleData.getValue();
+        final Any packedState = AnyPacker.pack(project);
+        stand.update(projectId, packedState);
+
+        assertEquals(packedState, memoizeCallback.newEntityState);
+    }
+
+    @Test
+    public void allow_cancelling_subscriptions() {
+        final Stand stand = prepareStandWithAggregateRepo(mock(StandStorage.class));
+        final Target allCustomers = Queries.Targets.allOf(Customer.class);
+
+        final MemoizeEntityUpdateCallback memoizeCallback = new MemoizeEntityUpdateCallback();
+        final Subscription subscription = stand.subscribe(allCustomers);
+        stand.activate(subscription, memoizeCallback);
+        assertNull(memoizeCallback.newEntityState);
+
+        stand.cancel(subscription);
+
+        final Map.Entry<CustomerId, Customer> sampleData = fillSampleCustomers(1).entrySet()
+                                                                                 .iterator()
+                                                                                 .next();
+        final CustomerId customerId = sampleData.getKey();
+        final Customer customer = sampleData.getValue();
+        final Any packedState = AnyPacker.pack(customer);
+        stand.update(customerId, packedState);
+
+        assertNull(memoizeCallback.newEntityState);
+    }
+
+    @Test
+    public void do_not_fail_if_cancelling_inexistent_subscription() {
+        final Stand stand = Stand.newBuilder()
+                                 .build();
+        final Subscription inexistentSubscription = Subscription.newBuilder()
+                                                                .setId(UUID.randomUUID()
+                                                                           .toString())
+                                                                .build();
+        stand.cancel(inexistentSubscription);
+    }
+
+    @SuppressWarnings("MethodWithMultipleLoops")
+    @Test
+    public void trigger_each_subscription_callback_once_for_multiple_subscriptions() {
+        final Stand stand = prepareStandWithAggregateRepo(mock(StandStorage.class));
+        final Target allCustomers = Queries.Targets.allOf(Customer.class);
+
+        final Set<MemoizeEntityUpdateCallback> callbacks = newHashSet();
+        final int totalCallbacks = 100;
+
+        for (int callbackIndex = 0; callbackIndex < totalCallbacks; callbackIndex++) {
+            final MemoizeEntityUpdateCallback callback = subscribeWithCallback(stand, allCustomers);
+            callbacks.add(callback);
+        }
+
+        final Map.Entry<CustomerId, Customer> sampleData = fillSampleCustomers(1).entrySet()
+                                                                                 .iterator()
+                                                                                 .next();
+        final CustomerId customerId = sampleData.getKey();
+        final Customer customer = sampleData.getValue();
+        final Any packedState = AnyPacker.pack(customer);
+        stand.update(customerId, packedState);
+
+        for (MemoizeEntityUpdateCallback callback : callbacks) {
+            assertEquals(packedState, callback.newEntityState);
+            verify(callback, times(1)).onStateChanged(any(Any.class));
+        }
+    }
+
+    @Test
+    public void do_not_trigger_subscription_callbacks_in_case_of_another_type_criterion_mismatch() {
+        final Stand stand = prepareStandWithAggregateRepo(mock(StandStorage.class));
+        final Target allProjects = Queries.Targets.allOf(Project.class);
+        final MemoizeEntityUpdateCallback callback = subscribeWithCallback(stand, allProjects);
+
+        final Map.Entry<CustomerId, Customer> sampleData = fillSampleCustomers(1).entrySet()
+                                                                                 .iterator()
+                                                                                 .next();
+        final CustomerId customerId = sampleData.getKey();
+        final Customer customer = sampleData.getValue();
+        final Any packedState = AnyPacker.pack(customer);
+        stand.update(customerId, packedState);
+
+        verify(callback, never()).onStateChanged(any(Any.class));
+    }
+
+    @Test
+    public void trigger_subscription_callbacks_matching_by_id() {
+        final Stand stand = prepareStandWithAggregateRepo(mock(StandStorage.class));
+
+        final Map<CustomerId, Customer> sampleCustomers = fillSampleCustomers(10);
+
+        final Target someCustomers = Queries.Targets.someOf(Customer.class, sampleCustomers.keySet());
+        final Set<Customer> callbackStates = newHashSet();
+        final MemoizeEntityUpdateCallback callback = new MemoizeEntityUpdateCallback() {
+            @Override
+            public void onStateChanged(Any newEntityState) {
+                super.onStateChanged(newEntityState);
+                final Customer customerInCallback = AnyPacker.unpack(newEntityState);
+                callbackStates.add(customerInCallback);
+            }
+        };
+        final Subscription subscription = stand.subscribe(someCustomers);
+        stand.activate(subscription, callback);
+
+        for (Map.Entry<CustomerId, Customer> sampleEntry : sampleCustomers.entrySet()) {
+            final CustomerId customerId = sampleEntry.getKey();
+            final Customer customer = sampleEntry.getValue();
+            final Any packedState = AnyPacker.pack(customer);
+            stand.update(customerId, packedState);
+        }
+
+        assertEquals(newHashSet(sampleCustomers.values()), callbackStates);
+    }
+
+    private static MemoizeEntityUpdateCallback subscribeWithCallback(Stand stand, Target subscriptionTarget) {
+        final MemoizeEntityUpdateCallback callback = spy(new MemoizeEntityUpdateCallback());
+        final Subscription subscription = stand.subscribe(subscriptionTarget);
+        stand.activate(subscription, callback);
+        assertNull(callback.newEntityState);
+        return callback;
+    }
+
+    private static CustomerId customerIdFor(int numericId) {
+        return CustomerId.newBuilder()
+                         .setNumber(numericId)
+                         .build();
+    }
+
+    private static ProjectId projectIdFor(int numericId) {
+        return ProjectId.newBuilder()
+                        .setId(String.valueOf(numericId))
+                        .build();
+    }
+
+    @Test
+    public void retrieve_all_data_if_field_mask_is_not_set() {
+        final Stand stand = prepareStandWithAggregateRepo(InMemoryStandStorage.newBuilder()
+                                                                              .build());
+
+        final Customer sampleCustomer = getSampleCustomer();
+
+        stand.update(sampleCustomer.getId(), AnyPacker.pack(sampleCustomer));
+
+        final Query customerQuery = Queries.readAll(Customer.class);
+
+        //noinspection OverlyComplexAnonymousInnerClass
+        final MemoizeQueryResponseObserver observer = new MemoizeQueryResponseObserver() {
+            @Override
+            public void onNext(QueryResponse value) {
+                super.onNext(value);
+                final List<Any> messages = value.getMessagesList();
+                assertFalse(messages.isEmpty());
+
+                final Customer customer = AnyPacker.unpack(messages.get(0));
+                for (Descriptors.FieldDescriptor field : customer.getDescriptorForType()
+                                                                 .getFields()) {
+                    assertTrue(customer.getField(field)
+                                       .equals(sampleCustomer.getField(field)));
+                }
+            }
+        };
+
+        stand.execute(customerQuery, observer);
+
+        verifyObserver(observer);
+    }
+
+    @Test
+    public void retrieve_only_selected_param_for_query() {
+        requestSampleCustomer(new int[]{Customer.NAME_FIELD_NUMBER - 1}, new MemoizeQueryResponseObserver() {
+            @Override
+            public void onNext(QueryResponse value) {
+                super.onNext(value);
+
+                final List<Any> messages = value.getMessagesList();
+                assertFalse(messages.isEmpty());
+
+                final Customer sampleCustomer = getSampleCustomer();
+                final Customer customer = AnyPacker.unpack(messages.get(0));
+                assertTrue(customer.getName()
+                                   .equals(sampleCustomer.getName()));
+                assertFalse(customer.hasId());
+                assertTrue(customer.getNicknamesList()
+                                   .isEmpty());
+            }
+        });
+    }
+
+    @Test
+    public void retrieve_collection_fields_if_required() {
+        requestSampleCustomer(new int[]{Customer.NICKNAMES_FIELD_NUMBER - 1}, new MemoizeQueryResponseObserver() {
+            @Override
+            public void onNext(QueryResponse value) {
+                super.onNext(value);
+
+                final List<Any> messages = value.getMessagesList();
+                assertFalse(messages.isEmpty());
+
+                final Customer sampleCustomer = getSampleCustomer();
+                final Customer customer = AnyPacker.unpack(messages.get(0));
+                assertEquals(customer.getNicknamesList(), sampleCustomer.getNicknamesList());
+
+                assertFalse(customer.hasName());
+                assertFalse(customer.hasId());
+            }
+        });
+    }
+
+    @Test
+    public void retrieve_all_requested_fields() {
+        requestSampleCustomer(new int[]{Customer.NICKNAMES_FIELD_NUMBER - 1, Customer.ID_FIELD_NUMBER - 1},
+                              new MemoizeQueryResponseObserver() {
+                                  @Override
+                                  public void onNext(QueryResponse value) {
+                                      super.onNext(value);
+
+                                      final List<Any> messages = value.getMessagesList();
+                                      assertFalse(messages.isEmpty());
+
+                                      final Customer sampleCustomer = getSampleCustomer();
+                                      final Customer customer = AnyPacker.unpack(messages.get(0));
+                                      assertEquals(customer.getNicknamesList(), sampleCustomer.getNicknamesList());
+
+                                      assertFalse(customer.hasName());
+                                      assertTrue(customer.hasId());
+                                  }
+                              });
+    }
+
+    @Test
+    public void retrieve_whole_entity_if_nothing_is_requested() {
+        //noinspection ZeroLengthArrayAllocation
+        requestSampleCustomer(new int[]{}, getDuplicateCostumerStreamObserver());
+    }
+
+    @SuppressWarnings("MethodWithMultipleLoops")
+    @Test
+    public void select_entity_singleton_by_id_and_apply_field_masks() {
+        final Stand stand = prepareStandWithAggregateRepo(InMemoryStandStorage.newBuilder()
+                                                                              .build());
+        final String customerDescriptor = Customer.getDescriptor()
+                                                  .getFullName();
+        @SuppressWarnings("DuplicateStringLiteralInspection")   // clashes with non-related tests.
+        final String[] paths = {customerDescriptor + ".id", customerDescriptor + ".name"};
+        final FieldMask fieldMask = FieldMask.newBuilder()
+                                             .addAllPaths(Arrays.asList(paths))
+                                             .build();
+
+        final List<Customer> customers = new LinkedList<>();
+        final int count = 10;
+
+        for (int i = 0; i < count; i++) {
+            // Has new ID each time
+            final Customer customer = getSampleCustomer();
+            customers.add(customer);
+
+            stand.update(customer.getId(), AnyPacker.pack(customer));
+        }
+
+        final Set<CustomerId> ids = Collections.singleton(customers.get(0)
+                                                                   .getId());
+        final Query customerQuery = Queries.readByIds(Customer.class, ids, paths);
+
+        final MemoizeQueryResponseObserver observer = new MemoizeQueryResponseObserver();
+        stand.execute(customerQuery, observer);
+
+        final List<Any> read = observer.responseHandled.getMessagesList();
+        assertSize(1, read);
+
+        final Customer customer = AnyPacker.unpack(read.get(0));
+        assertMatches(customer, fieldMask);
+        assertTrue(ids.contains(customer.getId()));
+
+        verifyObserver(observer);
+    }
+
+    @Test
+    public void handle_mistakes_in_query_silently() {
+        //noinspection ZeroLengthArrayAllocation
+        final Stand stand = prepareStandWithAggregateRepo(InMemoryStandStorage.newBuilder()
+                                                                              .build());
+
+        final Customer sampleCustomer = getSampleCustomer();
+
+        stand.update(sampleCustomer.getId(), AnyPacker.pack(sampleCustomer));
+
+        // FieldMask with invalid type URLs.
+        final String[] paths = {"invalid_type_url_example", Project.getDescriptor()
+                                                                   .getFields()
+                                                                   .get(2).getFullName()};
+
+        final Query customerQuery = Queries.readAll(Customer.class, paths);
+
+        final MemoizeQueryResponseObserver observer = new MemoizeQueryResponseObserver() {
+            @Override
+            public void onNext(QueryResponse value) {
+                super.onNext(value);
+                final List<Any> messages = value.getMessagesList();
+                assertFalse(messages.isEmpty());
+
+                final Customer customer = AnyPacker.unpack(messages.get(0));
+
+                assertNotEquals(customer, null);
+
+                assertFalse(customer.hasId());
+                assertFalse(customer.hasName());
+                assertTrue(customer.getNicknamesList()
+                                   .isEmpty());
+            }
+        };
+
+        stand.execute(customerQuery, observer);
+
+        verifyObserver(observer);
+    }
+
+    private static void verifyObserver(MemoizeQueryResponseObserver observer) {
+        assertNotNull(observer.responseHandled);
+        assertTrue(observer.isCompleted);
+        assertNull(observer.throwable);
+    }
+
+    private static MemoizeQueryResponseObserver getDuplicateCostumerStreamObserver() {
+        return new MemoizeQueryResponseObserver() {
+            @Override
+            public void onNext(QueryResponse value) {
+                super.onNext(value);
+
+                final List<Any> messages = value.getMessagesList();
+                assertFalse(messages.isEmpty());
+
+                final Customer customer = AnyPacker.unpack(messages.get(0));
+                final Customer sampleCustomer = getSampleCustomer();
+
+                assertEquals(sampleCustomer.getName(), customer.getName());
+                assertEquals(sampleCustomer.getNicknamesList(), customer.getNicknamesList());
+                assertTrue(customer.hasId());
+            }
+        };
+    }
+
+    private static Customer getSampleCustomer() {
+        //noinspection NumericCastThatLosesPrecision
+        return Customer.newBuilder()
+                       .setId(CustomerId.newBuilder()
+                                        .setNumber((int) UUID.randomUUID()
+                                                             .getLeastSignificantBits()))
+                       .setName(PersonName.newBuilder()
+                                          .setGivenName("John")
+                                          .build())
+                       .addNicknames(PersonName.newBuilder()
+                                               .setGivenName("Johnny"))
+                       .addNicknames(PersonName.newBuilder()
+                                               .setGivenName("Big Guy"))
+                       .build();
+
+    }
+
+    private static void requestSampleCustomer(int[] fieldIndexes, final MemoizeQueryResponseObserver observer) {
+        final Stand stand = prepareStandWithAggregateRepo(InMemoryStandStorage.newBuilder()
+                                                                              .build());
+
+        final Customer sampleCustomer = getSampleCustomer();
+
+        stand.update(sampleCustomer.getId(), AnyPacker.pack(sampleCustomer));
+
+        final String[] paths = new String[fieldIndexes.length];
+
+        for (int i = 0; i < fieldIndexes.length; i++) {
+            paths[i] = Customer.getDescriptor()
+                               .getFields()
+                               .get(fieldIndexes[i])
+                               .getFullName();
+        }
+
+        final Query customerQuery = Queries.readAll(Customer.class, paths);
+
+        stand.execute(customerQuery, observer);
+
+        verifyObserver(observer);
+    }
+
+    private static void checkEmptyResultForTargetOnEmptyStorage(Query readCustomersQuery) {
+        final StandStorage standStorageMock = mock(StandStorage.class);
+        // Return an empty collection on {@link StandStorage#readAllByType(TypeUrl)} call.
+        final ImmutableList<EntityStorageRecord> emptyResultList = ImmutableList.<EntityStorageRecord>builder().build();
+        when(standStorageMock.readAllByType(any(TypeUrl.class))).thenReturn(emptyResultList);
+
+        final Stand stand = prepareStandWithAggregateRepo(standStorageMock);
+
+        final MemoizeQueryResponseObserver responseObserver = new MemoizeQueryResponseObserver();
+        stand.execute(readCustomersQuery, responseObserver);
+
+        final List<Any> messageList = checkAndGetMessageList(responseObserver);
+        assertTrue("Query returned a non-empty response message list though the target was empty", messageList.isEmpty());
+    }
+
+    private static void doCheckReadingProjectsById(int numberOfProjects) {
+        // Define the types and values used as a test data.
+        final Map<ProjectId, Project> sampleProjects = newHashMap();
+        final TypeUrl projectType = TypeUrl.of(Project.class);
+        fillSampleProjects(sampleProjects, numberOfProjects);
+
+        final StandTestProjectionRepository projectionRepository = mock(StandTestProjectionRepository.class);
+        when(projectionRepository.getEntityStateType()).thenReturn(projectType);
+        setupExpectedFindAllBehaviour(sampleProjects, projectionRepository);
+
+        final Stand stand = prepareStandWithProjectionRepo(projectionRepository);
+
+        final Query readMultipleProjects = Queries.readByIds(Project.class, sampleProjects.keySet());
+
+        final MemoizeQueryResponseObserver responseObserver = new MemoizeQueryResponseObserver();
+        stand.execute(readMultipleProjects, responseObserver);
+
+        final List<Any> messageList = checkAndGetMessageList(responseObserver);
+        assertEquals(sampleProjects.size(), messageList.size());
+        final Collection<Project> allCustomers = sampleProjects.values();
+        for (Any singleRecord : messageList) {
+            final Project unpackedSingleResult = AnyPacker.unpack(singleRecord);
+            assertTrue(allCustomers.contains(unpackedSingleResult));
+        }
+    }
+
+    @SuppressWarnings("MethodWithMultipleLoops")
+    private static void doCheckReadingCustomersByIdAndFieldMask(String... paths) {
+        final Stand stand = prepareStandWithAggregateRepo(InMemoryStandStorage.newBuilder()
+                                                                              .build());
+
+        final int querySize = 2;
+
+        final Set<CustomerId> ids = new HashSet<>();
+
+        for (int i = 0; i < querySize; i++) {
+            final Customer customer = getSampleCustomer().toBuilder()
+                                                         .setId(CustomerId.newBuilder()
+                                                                          .setNumber(i))
+                                                         .build();
+
+            stand.update(customer.getId(), AnyPacker.pack(customer));
+
+            ids.add(customer.getId());
+        }
+
+        final Query customerQuery = Queries.readByIds(Customer.class, ids, paths);
+
+        final FieldMask fieldMask = FieldMask.newBuilder()
+                                             .addAllPaths(Arrays.asList(paths))
+                                             .build();
+
+        final MemoizeQueryResponseObserver observer = new MemoizeQueryResponseObserver() {
+            @Override
+            public void onNext(QueryResponse value) {
+                super.onNext(value);
+                final List<Any> messages = value.getMessagesList();
+                assertSize(ids.size(), messages);
+
+                for (Any message : messages) {
+                    final Customer customer = AnyPacker.unpack(message);
+
+                    assertNotEquals(customer, null);
+
+                    assertMatches(customer, fieldMask);
+                }
+            }
+        };
+
+        stand.execute(customerQuery, observer);
+
+        verifyObserver(observer);
+    }
+
+    private static void doCheckReadingCustomersById(int numberOfCustomers) {
+        // Define the types and values used as a test data.
+        final TypeUrl customerType = TypeUrl.of(Customer.class);
+        final Map<CustomerId, Customer> sampleCustomers = fillSampleCustomers(numberOfCustomers);
+
+        // Prepare the stand and its mock storage to act.
+        final StandStorage standStorageMock = mock(StandStorage.class);
+        setupExpectedBulkReadBehaviour(sampleCustomers, customerType, standStorageMock);
+
+        final Stand stand = prepareStandWithAggregateRepo(standStorageMock);
+        triggerMultipleUpdates(sampleCustomers, stand);
+
+        final Query readMultipleCustomers = Queries.readByIds(Customer.class, sampleCustomers.keySet());
+
+        final MemoizeQueryResponseObserver responseObserver = new MemoizeQueryResponseObserver();
+        stand.execute(readMultipleCustomers, responseObserver);
+
+        final List<Any> messageList = checkAndGetMessageList(responseObserver);
+        assertEquals(sampleCustomers.size(), messageList.size());
+        final Collection<Customer> allCustomers = sampleCustomers.values();
+        for (Any singleRecord : messageList) {
+            final Customer unpackedSingleResult = AnyPacker.unpack(singleRecord);
+            assertTrue(allCustomers.contains(unpackedSingleResult));
+        }
+    }
+
+    private static void checkEmptyResultOnNonEmptyStorageForQueryTarget(Target customerTarget) {
+        final StandStorage standStorageMock = mock(StandStorage.class);
+
+        // Return non-empty results on any storage read call.
+        final EntityStorageRecord someRecord = EntityStorageRecord.getDefaultInstance();
+        final ImmutableList<EntityStorageRecord> nonEmptyList = ImmutableList.<EntityStorageRecord>builder().add(someRecord)
+                                                                                                            .build();
+        when(standStorageMock.readAllByType(any(TypeUrl.class))).thenReturn(nonEmptyList);
+        when(standStorageMock.read(any(AggregateStateId.class))).thenReturn(someRecord);
+        when(standStorageMock.readAll()).thenReturn(Maps.<AggregateStateId, EntityStorageRecord>newHashMap());
+        when(standStorageMock.readMultiple(ArgumentMatchers.<AggregateStateId>anyIterable())).thenReturn(nonEmptyList);
+
+        final Stand stand = prepareStandWithAggregateRepo(standStorageMock);
+
+        final Query queryWithNoFilters = Query.newBuilder()
+                                              .setTarget(customerTarget)
+                                              .build();
+
+        final MemoizeQueryResponseObserver responseObserver = new MemoizeQueryResponseObserver();
+        stand.execute(queryWithNoFilters, responseObserver);
+
+        verifyObserver(responseObserver);
+
+        final List<Any> messageList = checkAndGetMessageList(responseObserver);
+        assertTrue("Query returned a non-empty response message list " +
+                           "though the filter was not set", messageList.isEmpty());
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    private static void setupExpectedBulkReadBehaviour(Map<CustomerId, Customer> sampleCustomers, TypeUrl customerType,
+                                                       StandStorage standStorageMock) {
+        final ImmutableList.Builder<AggregateStateId> stateIdsBuilder = ImmutableList.builder();
+        final ImmutableList.Builder<EntityStorageRecord> recordsBuilder = ImmutableList.builder();
+        for (CustomerId customerId : sampleCustomers.keySet()) {
+            final AggregateStateId stateId = AggregateStateId.of(customerId, customerType);
+            final Customer customer = sampleCustomers.get(customerId);
+            final Any customerState = AnyPacker.pack(customer);
+            final EntityStorageRecord entityStorageRecord = EntityStorageRecord.newBuilder()
+                                                                               .setState(customerState)
+                                                                               .build();
+            stateIdsBuilder.add(stateId);
+            recordsBuilder.add(entityStorageRecord);
+
+            when(standStorageMock.read(eq(stateId))).thenReturn(entityStorageRecord);
+        }
+
+        final ImmutableList<AggregateStateId> stateIds = stateIdsBuilder.build();
+        final ImmutableList<EntityStorageRecord> records = recordsBuilder.build();
+
+        final Iterable<AggregateStateId> matchingIds = argThat(idsMatcher(stateIds));
+        when(standStorageMock.readMultiple(matchingIds)).thenReturn(records);
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    private static void setupExpectedFindAllBehaviour(Map<ProjectId, Project> sampleProjects,
+                                                      StandTestProjectionRepository projectionRepository) {
+
+        final Set<ProjectId> projectIds = sampleProjects.keySet();
+        final ImmutableCollection<Given.StandTestProjection> allResults = toProjectionCollection(projectIds);
+
+        for (ProjectId projectId : projectIds) {
+            when(projectionRepository.load(eq(projectId))).thenReturn(new StandTestProjection(projectId));
+        }
+
+        final Iterable<ProjectId> matchingIds = argThat(projectionIdsIterableMatcher(projectIds));
+
+        when(projectionRepository.loadAll(matchingIds, any(FieldMask.class))).thenReturn(allResults);
+
+        when(projectionRepository.loadAll()).thenReturn(allResults);
+
+        final EntityFilters matchingFilter = argThat(entityFilterMatcher(projectIds));
+        when(projectionRepository.find(matchingFilter, any(FieldMask.class))).thenReturn(allResults);
+    }
+
+    @SuppressWarnings("OverlyComplexAnonymousInnerClass")
+    private static ArgumentMatcher<EntityFilters> entityFilterMatcher(final Collection<ProjectId> projectIds) {
+        // This argument matcher does NOT mimic the exact repository behavior.
+        // Instead, it only matches the EntityFilters instance in case it has EntityIdFilter with ALL the expected IDs.
+        return new ArgumentMatcher<EntityFilters>() {
+            @Override
+            public boolean matches(EntityFilters argument) {
+                boolean everyElementPresent = true;
+                for (EntityId entityId : argument.getIdFilter()
+                                                 .getIdsList()) {
+                    final Any idAsAny = entityId.getId();
+                    final Message rawId = AnyPacker.unpack(idAsAny);
+                    if (rawId instanceof ProjectId) {
+                        final ProjectId convertedProjectId = (ProjectId) rawId;
+                        everyElementPresent = everyElementPresent && projectIds.contains(convertedProjectId);
+                    } else {
+                        everyElementPresent = false;
+                    }
+                }
+                return everyElementPresent;
+            }
+        };
+    }
+
+    private static ImmutableCollection<Given.StandTestProjection> toProjectionCollection(Collection<ProjectId> values) {
+        final Collection<Given.StandTestProjection> transformed =
+                Collections2.transform(values,
+                                       new Function<ProjectId, Given.StandTestProjection>() {
+                                           @Nullable
+                                           @Override
+                                           public StandTestProjection apply(@Nullable ProjectId input) {
+                                               checkNotNull(input);
+                                               return new StandTestProjection(input);
+                                           }
+                                       });
+        final ImmutableList<Given.StandTestProjection> result = ImmutableList.copyOf(transformed);
+        return result;
+    }
+
+    private static ArgumentMatcher<Iterable<ProjectId>> projectionIdsIterableMatcher(final Set<ProjectId> projectIds) {
+        return new ArgumentMatcher<Iterable<ProjectId>>() {
+            @Override
+            public boolean matches(Iterable<ProjectId> argument) {
+                boolean everyElementPresent = true;
+                for (ProjectId projectId : argument) {
+                    everyElementPresent = everyElementPresent && projectIds.contains(projectId);
+                }
+                return everyElementPresent;
+            }
+        };
+    }
+
+    private static ArgumentMatcher<Iterable<AggregateStateId>> idsMatcher(final List<AggregateStateId> stateIds) {
+        return new ArgumentMatcher<Iterable<AggregateStateId>>() {
+            @Override
+            public boolean matches(Iterable<AggregateStateId> argument) {
+                boolean everyElementPresent = true;
+                for (AggregateStateId aggregateStateId : argument) {
+                    everyElementPresent = everyElementPresent && stateIds.contains(aggregateStateId);
+                }
+                return everyElementPresent;
+            }
+        };
+    }
+
+    private static void triggerMultipleUpdates(Map<CustomerId, Customer> sampleCustomers, Stand stand) {
+        // Trigger the aggregate state updates.
+        for (CustomerId id : sampleCustomers.keySet()) {
+            final Customer sampleCustomer = sampleCustomers.get(id);
+            final Any customerState = AnyPacker.pack(sampleCustomer);
+            stand.update(id, customerState);
+        }
+    }
+
+    private static Map<CustomerId, Customer> fillSampleCustomers(int numberOfCustomers) {
+        final Map<CustomerId, Customer> sampleCustomers = newHashMap();
+
+        @SuppressWarnings("UnsecureRandomNumberGeneration")
+        final Random randomizer = new Random(Integer.MAX_VALUE);    // force non-negative numeric ID values.
+
+        for (int customerIndex = 0; customerIndex < numberOfCustomers; customerIndex++) {
+
+            final int numericId = randomizer.nextInt();
+            final CustomerId customerId = customerIdFor(numericId);
+            final Customer customer = Customer.newBuilder()
+                                              .setName(PersonName.newBuilder()
+                                                                 .setGivenName(String.valueOf(numericId)))
+                                              .build();
+            sampleCustomers.put(customerId, customer);
+        }
+        return sampleCustomers;
+    }
+
+    private static Map<ProjectId, Project> fillSampleProjects(int numberOfProjects) {
+        final Map<ProjectId, Project> sampleProjects = newHashMap();
+
+        @SuppressWarnings("UnsecureRandomNumberGeneration")
+        final Random randomizer = new Random(Integer.MAX_VALUE);    // force non-negative numeric ID values.
+
+        for (int projectIndex = 0; projectIndex < numberOfProjects; projectIndex++) {
+
+            final int numericId = randomizer.nextInt();
+            final ProjectId customerId = projectIdFor(numericId);
+
+            final Project project = Project.newBuilder()
+                                           .setName(String.valueOf(numericId))
+                                           .build();
+            sampleProjects.put(customerId, project);
+        }
+        return sampleProjects;
+    }
+
+    private static void fillSampleProjects(Map<ProjectId, Project> sampleProjects, int numberOfProjects) {
+        for (int projectIndex = 0; projectIndex < numberOfProjects; projectIndex++) {
+            final Project project = Project.getDefaultInstance();
+            final ProjectId projectId = ProjectId.newBuilder()
+                                                 .setId(UUID.randomUUID()
+                                                            .toString())
+                                                 .build();
+            sampleProjects.put(projectId, project);
+        }
+    }
+
+    private static List<Any> checkAndGetMessageList(MemoizeQueryResponseObserver responseObserver) {
+        assertTrue("Query has not completed successfully", responseObserver.isCompleted);
+        assertNull("Throwable has been caught upon query execution", responseObserver.throwable);
+
+        final QueryResponse response = responseObserver.responseHandled;
+        assertEquals("Query response is not OK", Responses.ok(), response.getResponse());
+        assertNotNull("Query response must not be null", response);
+
+        final List<Any> messageList = response.getMessagesList();
+        assertNotNull("Query response has null message list", messageList);
+        return messageList;
+    }
+
+    private static Stand prepareStandWithAggregateRepo(StandStorage standStorage) {
+        final Stand stand = Stand.newBuilder()
+                                 .setStorage(standStorage)
+                                 .build();
+        assertNotNull(stand);
+
+        final BoundedContext boundedContext = newBoundedContext(stand);
+        final CustomerAggregateRepository customerAggregateRepo = new CustomerAggregateRepository(boundedContext);
+        stand.registerTypeSupplier(customerAggregateRepo);
+        return stand;
+    }
+
+    private static Stand prepareStandWithProjectionRepo(ProjectionRepository projectionRepository) {
+        final Stand stand = Stand.newBuilder()
+                                 .build();
+        assertNotNull(stand);
+        stand.registerTypeSupplier(projectionRepository);
+        return stand;
+    }
+
+    private static EntityStorageRecord recordStateMatcher(final EntityStorageRecord expectedRecord) {
+        return argThat(new ArgumentMatcher<EntityStorageRecord>() {
+            @Override
+            public boolean matches(EntityStorageRecord argument) {
+                final boolean matchResult = Objects.equals(expectedRecord.getState(), argument.getState());
+                return matchResult;
+            }
+        });
+    }
+
+    private static void checkTypesEmpty(Stand stand) {
+        assertTrue(stand.getExposedTypes()
+                        .isEmpty());
+        assertTrue(stand.getExposedAggregateTypes()
+                        .isEmpty());
+    }
+
+    private static void checkHasExactlyOne(Set<TypeUrl> availableTypes, Descriptors.Descriptor expectedType) {
+        assertEquals(1, availableTypes.size());
+
+        final TypeUrl actualTypeUrl = availableTypes.iterator()
+                                                    .next();
+        final TypeUrl expectedTypeUrl = TypeUrl.of(expectedType);
+        assertEquals("Type was registered incorrectly", expectedTypeUrl, actualTypeUrl);
+    }
+
+    private static Stand.EntityUpdateCallback emptyUpdateCallback() {
+        return new Stand.EntityUpdateCallback() {
+            @Override
+            public void onStateChanged(Any newEntityState) {
+                //do nothing
+            }
+        };
+    }
+
+    private static void assertMatches(Message message, FieldMask fieldMask) {
+        final List<String> paths = fieldMask.getPathsList();
+        for (Descriptors.FieldDescriptor field : message.getDescriptorForType()
+                                                        .getFields()) {
+
+            // Protobuf limitation, has no effect on the test.
+            if (field.isRepeated()) {
+                continue;
+            }
+
+            assertEquals(message.hasField(field), paths.contains(field.getFullName()));
+        }
+    }
+
+    // ***** Inner classes used for tests. *****
+
+    /**
+     * A {@link StreamObserver} storing the state of {@link Query} execution.
+     */
+    private static class MemoizeQueryResponseObserver implements StreamObserver<QueryResponse> {
+
+        private QueryResponse responseHandled;
+        private Throwable throwable;
+        private boolean isCompleted = false;
+
+        @Override
+        public void onNext(QueryResponse response) {
+            this.responseHandled = response;
+        }
+
+        @Override
+        public void onError(Throwable throwable) {
+            this.throwable = throwable;
+        }
+
+        @Override
+        public void onCompleted() {
+            this.isCompleted = true;
+        }
+
+    }
+
+    private static class MemoizeEntityUpdateCallback implements Stand.EntityUpdateCallback {
+
+        private Any newEntityState;
+
+        @Override
+        public void onStateChanged(Any newEntityState) {
+            this.newEntityState = newEntityState;
+        }
+    }
+}
diff --git a/server/src/test/java/org/spine3/server/stand/SubscriptionRecordShould.java b/server/src/test/java/org/spine3/server/stand/SubscriptionRecordShould.java
new file mode 100644
index 00000000000..2cd60321ede
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/stand/SubscriptionRecordShould.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.stand;
+
+import com.google.protobuf.Any;
+import com.google.protobuf.Message;
+import org.junit.Test;
+import org.spine3.base.Queries;
+import org.spine3.client.Subscription;
+import org.spine3.client.Target;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.test.aggregate.Project;
+import org.spine3.test.aggregate.ProjectId;
+import org.spine3.test.commandservice.customer.Customer;
+
+import java.util.Collections;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Dmytro Dashenkov
+ */
+public class SubscriptionRecordShould {
+
+    @Test
+    public void match_record_to_given_parameters() {
+        final SubscriptionRecord matchingRecord = new SubscriptionRecord(Given.subscription(),
+                                                                         Given.target(),
+                                                                         Given.TYPE);
+        final Project entityState = Project.getDefaultInstance();
+        final Any wrappedState = AnyPacker.pack(entityState);
+        final ProjectId redundantId = ProjectId.getDefaultInstance();
+
+        final boolean matchResult = matchingRecord.matches(Given.TYPE, redundantId, wrappedState);
+        assertTrue(matchResult);
+    }
+
+    @Test
+    public void fail_to_match_improper_type() {
+        final SubscriptionRecord notMatchingRecord = new SubscriptionRecord(Given.subscription(),
+                                                                            Given.target(),
+                                                                            Given.TYPE);
+        final Project entityState = Project.getDefaultInstance();
+        final Any wrappedState = AnyPacker.pack(entityState);
+        final ProjectId redundantId = ProjectId.getDefaultInstance();
+
+        final boolean matchResult = notMatchingRecord.matches(Given.OTHER_TYPE, redundantId, wrappedState);
+        assertFalse(matchResult);
+    }
+
+    @Test
+    public void fail_to_match_improper_target() {
+        final ProjectId nonExistingId = ProjectId.newBuilder()
+                                                 .setId("never-existed")
+                                                 .build();
+        final SubscriptionRecord notMatchingRecord = new SubscriptionRecord(Given.subscription(),
+                                                                            Given.target(nonExistingId),
+                                                                            Given.TYPE);
+        final Project entityState = Project.getDefaultInstance();
+        final Any wrappedState = AnyPacker.pack(entityState);
+        final ProjectId redundantId = ProjectId.getDefaultInstance();
+
+        final boolean matchResult = notMatchingRecord.matches(Given.TYPE, redundantId, wrappedState);
+        assertFalse(matchResult);
+    }
+
+    @Test
+    public void be_equal_if_has_same_subscription() {
+        final Subscription oneSubscription = Given.subscription();
+        final Subscription otherSubscription = Subscription.newBuilder()
+                                                           .setId("breaking-id")
+                                                           .build();
+        @SuppressWarnings("QuestionableName")
+        final SubscriptionRecord one = new SubscriptionRecord(oneSubscription,
+                                                              Given.target(),
+                                                              Given.TYPE);
+        final SubscriptionRecord similar = new SubscriptionRecord(otherSubscription,
+                                                                  Given.target(),
+                                                                  Given.TYPE);
+        final SubscriptionRecord same = new SubscriptionRecord(oneSubscription,
+                                                               Given.target(),
+                                                               Given.TYPE);
+        assertFalse(one.equals(similar));
+        assertTrue(one.equals(same));
+    }
+
+    @SuppressWarnings("UtilityClass")
+    private static class Given {
+
+        private static final TypeUrl TYPE = TypeUrl.of(Project.class);
+        private static final TypeUrl OTHER_TYPE = TypeUrl.of(Customer.class);
+
+        private static Target target() {
+            final Target target = Queries.Targets.allOf(Project.class);
+            return target;
+        }
+
+        private static Target target(Message targetId) {
+            final Target target = Queries.Targets.someOf(Project.class, Collections.singleton(targetId));
+            return target;
+        }
+
+        private static Subscription subscription() {
+            final Subscription subscription = Subscription.getDefaultInstance();
+            return subscription;
+        }
+    }
+}
diff --git a/server/src/test/java/org/spine3/server/storage/AggregateStorageShould.java b/server/src/test/java/org/spine3/server/storage/AggregateStorageShould.java
index 13ed3d836d4..c6a68090beb 100644
--- a/server/src/test/java/org/spine3/server/storage/AggregateStorageShould.java
+++ b/server/src/test/java/org/spine3/server/storage/AggregateStorageShould.java
@@ -159,7 +159,7 @@ public void write_and_read_event_by_Integer_id() {
     public void write_and_read_one_record() {
         final AggregateStorageRecord expected = Given.AggregateStorageRecord.create(getCurrentTime());
 
-        storage.writeInternal(id, expected);
+        storage.writeRecord(id, expected);
 
         final Iterator<AggregateStorageRecord> iterator = storage.historyBackward(id);
         assertTrue(iterator.hasNext());
@@ -205,7 +205,7 @@ public void write_records_and_load_history_till_last_snapshot() {
         final Timestamp time2 = add(time1, delta);
         final Timestamp time3 = add(time2, delta);
 
-        storage.writeInternal(id, Given.AggregateStorageRecord.create(time1));
+        storage.writeRecord(id, Given.AggregateStorageRecord.create(time1));
         storage.write(id, newSnapshot(time2));
 
         testWriteRecordsAndLoadHistory(time3);
@@ -284,7 +284,7 @@ protected void testWriteRecordsAndLoadHistory(Timestamp firstRecordTime) {
 
     protected void writeAll(ProjectId id, Iterable<AggregateStorageRecord> records) {
         for (AggregateStorageRecord record : records) {
-            storage.writeInternal(id, record);
+            storage.writeRecord(id, record);
         }
     }
 
diff --git a/server/src/test/java/org/spine3/server/storage/EntityStorageShould.java b/server/src/test/java/org/spine3/server/storage/EntityStorageShould.java
index 4201c8f71fc..6d3225d4e4a 100644
--- a/server/src/test/java/org/spine3/server/storage/EntityStorageShould.java
+++ b/server/src/test/java/org/spine3/server/storage/EntityStorageShould.java
@@ -39,7 +39,7 @@
 public abstract class EntityStorageShould<I> extends AbstractStorageShould<I, EntityStorageRecord> {
 
     @Override
-    protected abstract EntityStorage<I> getStorage();
+    protected abstract RecordStorage<I> getStorage();
 
     /**
      * Used to get a storage in tests with different ID types.
@@ -49,7 +49,7 @@ public abstract class EntityStorageShould<I> extends AbstractStorageShould<I, En
      * @param <Id> the type of Entity IDs
      * @return an empty storage instance
      */
-    protected abstract <Id> EntityStorage<Id> getStorage(Class<? extends Entity<Id, ?>> entityClass);
+    protected abstract <Id> RecordStorage<Id> getStorage(Class<? extends Entity<Id, ?>> entityClass);
 
     @Override
     protected EntityStorageRecord newStorageRecord() {
@@ -58,33 +58,33 @@ protected EntityStorageRecord newStorageRecord() {
 
     @Test
     public void write_and_read_record_by_Message_id() {
-        final EntityStorage<ProjectId> storage = getStorage(TestEntityWithIdMessage.class);
+        final RecordStorage<ProjectId> storage = getStorage(TestEntityWithIdMessage.class);
         final ProjectId id = Given.AggregateId.newProjectId(newUuid());
         writeAndReadRecordTest(id, storage);
     }
 
     @Test
     public void write_and_read_record_by_String_id() {
-        final EntityStorage<String> storage = getStorage(TestEntityWithIdString.class);
+        final RecordStorage<String> storage = getStorage(TestEntityWithIdString.class);
         final String id = newUuid();
         writeAndReadRecordTest(id, storage);
     }
 
     @Test
     public void write_and_read_record_by_Long_id() {
-        final EntityStorage<Long> storage = getStorage(TestEntityWithIdLong.class);
+        final RecordStorage<Long> storage = getStorage(TestEntityWithIdLong.class);
         final long id = 10L;
         writeAndReadRecordTest(id, storage);
     }
 
     @Test
     public void write_and_read_record_by_Integer_id() {
-        final EntityStorage<Integer> storage = getStorage(TestEntityWithIdInteger.class);
+        final RecordStorage<Integer> storage = getStorage(TestEntityWithIdInteger.class);
         final int id = 10;
         writeAndReadRecordTest(id, storage);
     }
 
-    protected <Id> void writeAndReadRecordTest(Id id, EntityStorage<Id> storage) {
+    protected <Id> void writeAndReadRecordTest(Id id, RecordStorage<Id> storage) {
         final EntityStorageRecord expected = newStorageRecord();
         storage.write(id, expected);
 
diff --git a/server/src/test/java/org/spine3/server/storage/EventStorageShould.java b/server/src/test/java/org/spine3/server/storage/EventStorageShould.java
index 9e1b44004d9..7df8bf0eef3 100644
--- a/server/src/test/java/org/spine3/server/storage/EventStorageShould.java
+++ b/server/src/test/java/org/spine3/server/storage/EventStorageShould.java
@@ -107,7 +107,7 @@ public void writeInternal_and_read_one_event() {
         final EventId id = EventId.newBuilder().setUuid(recordToStore.getEventId()).build();
         final Event expected = toEvent(recordToStore);
 
-        storage.writeInternal(recordToStore);
+        storage.writeRecord(recordToStore);
         final Event actual = storage.read(id);
 
         assertEquals(expected, actual);
@@ -400,7 +400,7 @@ private void givenSequentialRecords(long deltaSeconds, int deltaNanos) {
 
     protected void writeAll(EventStorageRecord... records) {
         for (EventStorageRecord r : records) {
-            storage.writeInternal(r);
+            storage.writeRecord(r);
         }
     }
 
diff --git a/server/src/test/java/org/spine3/server/storage/ProjectionStorageShould.java b/server/src/test/java/org/spine3/server/storage/ProjectionStorageShould.java
index b02a910271e..825bd2b64c3 100644
--- a/server/src/test/java/org/spine3/server/storage/ProjectionStorageShould.java
+++ b/server/src/test/java/org/spine3/server/storage/ProjectionStorageShould.java
@@ -20,17 +20,34 @@
 
 package org.spine3.server.storage;
 
+import com.google.protobuf.Any;
+import com.google.protobuf.FieldMask;
 import com.google.protobuf.Timestamp;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
+import org.spine3.protobuf.AnyPacker;
 import org.spine3.protobuf.Durations;
+import org.spine3.protobuf.Timestamps;
 import org.spine3.test.Tests;
+import org.spine3.test.projection.Project;
+import org.spine3.test.projection.ProjectId;
+import org.spine3.test.projection.Task;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
 
 import static com.google.protobuf.util.Timestamps.add;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 import static org.spine3.protobuf.Timestamps.getCurrentTime;
+import static org.spine3.test.Tests.assertMatchesMask;
+import static org.spine3.test.Verify.assertContains;
+import static org.spine3.test.Verify.assertEmpty;
+import static org.spine3.test.Verify.assertSize;
 import static org.spine3.testdata.TestEntityStorageRecordFactory.newEntityStorageRecord;
 
 /**
@@ -69,6 +86,91 @@ public void return_null_if_no_event_time_in_storage() {
         assertNull(time);
     }
 
+    @SuppressWarnings("MethodWithMultipleLoops")
+    @Test
+    public void read_all_messages() {
+        final List<I> ids = fillStorage(5);
+
+        final Map<I, EntityStorageRecord> read = storage.readAll();
+        assertSize(ids.size(), read);
+        for (Map.Entry<I, EntityStorageRecord> record : read.entrySet()) {
+            assertContains(record.getKey(), ids);
+        }
+    }
+
+    @SuppressWarnings("MethodWithMultipleLoops")
+    @Test
+    public void read_all_messages_with_field_mask() {
+        final List<I> ids = fillStorage(5);
+
+        final String projectDescriptor = Project.getDescriptor()
+                                                .getFullName();
+        @SuppressWarnings("DuplicateStringLiteralInspection")       // clashes with non-related tests.
+        final FieldMask fieldMask = maskForPaths(projectDescriptor + ".id", projectDescriptor + ".name");
+
+        final Map<I, EntityStorageRecord> read = storage.readAll(fieldMask);
+        assertSize(ids.size(), read);
+        for (Map.Entry<I, EntityStorageRecord> record : read.entrySet()) {
+            assertContains(record.getKey(), ids);
+
+            final Any packedState = record.getValue()
+                                          .getState();
+            final Project state = AnyPacker.unpack(packedState);
+            assertMatchesMask(state, fieldMask);
+        }
+    }
+
+    @Test
+    public void retrieve_empty_map_if_storage_is_empty() {
+        final Map<I, EntityStorageRecord> noMaskEntiries = storage.readAll();
+
+        final FieldMask nonEmptyMask = FieldMask.newBuilder()
+                                                .addPaths("invalid_path")
+                                                .build();
+        final Map<I, EntityStorageRecord> maskedEntries = storage.readAll(nonEmptyMask);
+
+        assertEmpty(noMaskEntiries);
+        assertEmpty(maskedEntries);
+
+        // Same type
+        assertEquals(noMaskEntiries, maskedEntries);
+    }
+
+    @SuppressWarnings({"MethodWithMultipleLoops", "BreakStatement"})
+    @Test
+    public void perform_read_bulk_operations() {
+        // Get a subset of IDs
+        final List<I> ids = fillStorage(10).subList(0, 5);
+
+        final Iterable<EntityStorageRecord> read = storage.readMultiple(ids);
+        assertSize(ids.size(), read);
+
+        // Check data consistency
+        for (EntityStorageRecord record : read) {
+            checkProjectIdIsInList(record, ids);
+        }
+    }
+
+    @SuppressWarnings({"MethodWithMultipleLoops", "BreakStatement"})
+    @Test
+    public void perform_bulk_read_with_field_mask_operation() {
+        // Get a subset of IDs
+        final List<I> ids = fillStorage(10).subList(0, 5);
+
+        final String projectDescriptor = Project.getDescriptor()
+                                                .getFullName();
+        final FieldMask fieldMask = maskForPaths(projectDescriptor + ".id", projectDescriptor + ".status");
+
+        final Iterable<EntityStorageRecord> read = storage.readMultiple(ids, fieldMask);
+        assertSize(ids.size(), read);
+
+        // Check data consistency
+        for (EntityStorageRecord record : read) {
+            final Project state = checkProjectIdIsInList(record, ids);
+            assertMatchesMask(state, fieldMask);
+        }
+    }
+
     @Test(expected = NullPointerException.class)
     public void throw_exception_if_write_null_event_time() {
         storage.writeLastHandledEventTime(Tests.<Timestamp>nullRef());
@@ -87,6 +189,26 @@ public void write_and_read_last_event_time_several_times() {
         writeAndReadLastEventTimeTest(time2);
     }
 
+    private List<I> fillStorage(int count) {
+        final List<I> ids = new LinkedList<>();
+
+        for (int i = 0; i < count; i++) {
+            final I id = newId();
+            final Project state = Given.project(id.toString(), String.format("project-%d", i));
+            final Any packedState = AnyPacker.pack(state);
+
+            final EntityStorageRecord record = EntityStorageRecord.newBuilder()
+                                                                  .setState(packedState)
+                                                                  .setWhenModified(Timestamps.getCurrentTime())
+                                                                  .setVersion(1)
+                                                                  .build();
+            storage.write(id, record);
+            ids.add(id);
+        }
+
+        return ids;
+    }
+
     private void writeAndReadLastEventTimeTest(Timestamp expected) {
         storage.writeLastHandledEventTime(expected);
 
@@ -94,4 +216,47 @@ private void writeAndReadLastEventTimeTest(Timestamp expected) {
 
         assertEquals(expected, actual);
     }
+
+    @SuppressWarnings("BreakStatement")
+    private static <I> Project checkProjectIdIsInList(EntityStorageRecord project, List<I> ids) {
+        final Any packedState = project.getState();
+        final Project state = AnyPacker.unpack(packedState);
+        final ProjectId id = state.getId();
+        final String stringIdRepr = id.getId();
+
+        boolean isIdPresent = false;
+        for (I genericId : ids) {
+            isIdPresent = genericId.toString()
+                                   .equals(stringIdRepr);
+            if (isIdPresent) {
+                break;
+            }
+        }
+        assertTrue(isIdPresent);
+
+        return state;
+    }
+
+    private static FieldMask maskForPaths(String... paths) {
+        final FieldMask mask = FieldMask.newBuilder()
+                                        .addAllPaths(Arrays.asList(paths))
+                                        .build();
+        return mask;
+    }
+
+    private static class Given {
+
+        private static Project project(String id, String name) {
+            final ProjectId projectId = ProjectId.newBuilder()
+                                                 .setId(id)
+                                                 .build();
+            final Project project = Project.newBuilder()
+                                           .setId(projectId)
+                                           .setName(name)
+                                           .setStatus(Project.Status.CREATED)
+                                           .addTask(Task.getDefaultInstance())
+                                           .build();
+            return project;
+        }
+    }
 }
diff --git a/server/src/test/java/org/spine3/server/storage/RecordStorageShould.java b/server/src/test/java/org/spine3/server/storage/RecordStorageShould.java
new file mode 100644
index 00000000000..39272553426
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/storage/RecordStorageShould.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.storage;
+
+import com.google.protobuf.FieldMask;
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.junit.Assert.assertNotNull;
+import static org.spine3.test.Verify.assertEmpty;
+
+/**
+ * @author Dmytro Dashenkov
+ */
+public abstract class RecordStorageShould {
+
+    @Test
+    public void retrieve_empty_map_if_storage_is_empty() {
+        final RecordStorage<String> storage = createStorage();
+
+        final FieldMask nonEmptyFieldMask = FieldMask.newBuilder()
+                                                     .addPaths("invalid-path")
+                                                     .build();
+
+        final Map empty = storage.readAll(nonEmptyFieldMask);
+        assertNotNull(empty);
+        assertEmpty(empty);
+    }
+
+    protected abstract <T> RecordStorage<T> createStorage();
+}
diff --git a/server/src/test/java/org/spine3/server/storage/StandStorageShould.java b/server/src/test/java/org/spine3/server/storage/StandStorageShould.java
new file mode 100644
index 00000000000..3b762b228bf
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/storage/StandStorageShould.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.storage;
+
+import com.google.common.base.Function;
+import com.google.common.base.Supplier;
+import com.google.common.collect.Collections2;
+import com.google.protobuf.Any;
+import org.junit.Test;
+import org.spine3.base.Identifiers;
+import org.spine3.protobuf.AnyPacker;
+import org.spine3.protobuf.Timestamps;
+import org.spine3.protobuf.TypeUrl;
+import org.spine3.server.stand.AggregateStateId;
+import org.spine3.test.projection.Project;
+import org.spine3.test.projection.ProjectId;
+import org.spine3.test.projection.Task;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import static org.spine3.test.Verify.assertContains;
+import static org.spine3.test.Verify.assertSize;
+
+/**
+ * @author Dmytro Dashenkov
+ */
+public abstract class StandStorageShould {
+
+    protected abstract StandStorage createStorage();
+
+    protected static final Supplier<AggregateStateId<ProjectId>> DEFAULT_ID_SUPPLIER
+            = new Supplier<AggregateStateId<ProjectId>>() {
+        @SuppressWarnings("unchecked")
+        @Override
+        public AggregateStateId<ProjectId> get() {
+            final ProjectId projectId = ProjectId.newBuilder()
+                                                 .setId(Identifiers.newUuid())
+                                                 .build();
+            return AggregateStateId.of(projectId, TypeUrl.of(Project.class));
+        }
+    };
+
+    @Test
+    public void retrieve_all_records() {
+        final StandStorage storage = createStorage();
+        final List<AggregateStateId> ids = fill(storage, 10, DEFAULT_ID_SUPPLIER);
+
+        final Map<AggregateStateId, EntityStorageRecord> allRecords = storage.readAll();
+        checkIds(ids, allRecords.values());
+    }
+
+    @Test
+    public void retrieve_records_by_ids() {
+        final StandStorage storage = createStorage();
+        // Use a subset of IDs
+        final List<AggregateStateId> ids = fill(storage, 10, DEFAULT_ID_SUPPLIER).subList(0, 5);
+
+        final Collection<EntityStorageRecord> records = (Collection<EntityStorageRecord>) storage.readMultiple(ids);
+        checkIds(ids, records);
+    }
+
+    protected static List<AggregateStateId> fill(StandStorage storage,
+                                                 int count,
+                                                 Supplier<AggregateStateId<ProjectId>> idSupplier) {
+        final List<AggregateStateId> ids = new LinkedList<>();
+
+        for (int i = 0; i < count; i++) {
+            final AggregateStateId genericId = idSupplier.get();
+            final ProjectId id = (ProjectId) genericId.getAggregateId();
+            final Project project = Project.newBuilder()
+                                           .setId(id)
+                                           .setStatus(Project.Status.CREATED)
+                                           .setName(String.format("test-project-%s", i))
+                                           .addTask(Task.getDefaultInstance())
+                                           .build();
+            final EntityStorageRecord record = EntityStorageRecord.newBuilder()
+                                                                  .setState(AnyPacker.pack(project))
+                                                                  .setWhenModified(Timestamps.getCurrentTime())
+                                                                  .setVersion(1)
+                                                                  .build();
+            storage.write(genericId, record);
+            ids.add(genericId);
+        }
+
+        return ids;
+    }
+
+    protected void checkIds(List<AggregateStateId> ids, Collection<EntityStorageRecord> records) {
+        assertSize(ids.size(), records);
+
+        final Collection<ProjectId> projectIds = Collections2.transform(ids, new Function<AggregateStateId, ProjectId>() {
+            @Nullable
+            @Override
+            public ProjectId apply(@Nullable AggregateStateId input) {
+                if (input == null) {
+                    return null;
+                }
+                return (ProjectId) input.getAggregateId();
+            }
+        });
+
+        for (EntityStorageRecord record : records) {
+            final Any packedState = record.getState();
+            final Project state = AnyPacker.unpack(packedState);
+            final ProjectId id = state.getId();
+
+            assertContains(id, projectIds);
+        }
+    }
+
+}
diff --git a/server/src/test/java/org/spine3/server/storage/memory/InMemoryEntityStorageShould.java b/server/src/test/java/org/spine3/server/storage/memory/InMemoryEntityStorageShould.java
index b2548297724..94a542ed1b7 100644
--- a/server/src/test/java/org/spine3/server/storage/memory/InMemoryEntityStorageShould.java
+++ b/server/src/test/java/org/spine3/server/storage/memory/InMemoryEntityStorageShould.java
@@ -21,26 +21,26 @@
 package org.spine3.server.storage.memory;
 
 import org.spine3.server.entity.Entity;
-import org.spine3.server.storage.EntityStorage;
+import org.spine3.server.storage.RecordStorage;
 import org.spine3.server.storage.EntityStorageShould;
 
 import static org.spine3.base.Identifiers.newUuid;
 
 /**
- * Tests of an in-memory {@link EntityStorage} implementation.
+ * Tests of an in-memory {@link RecordStorage} implementation.
  *
  * @author Alexander Litus
  */
 public class InMemoryEntityStorageShould extends EntityStorageShould<String> {
 
     @Override
-    protected EntityStorage<String> getStorage() {
-        return InMemoryEntityStorage.newInstance(false);
+    protected RecordStorage<String> getStorage() {
+        return InMemoryRecordStorage.newInstance(false);
     }
 
     @Override
-    protected <Id> EntityStorage<Id> getStorage(Class<? extends Entity<Id, ?>> entityClass) {
-        return InMemoryEntityStorage.newInstance(false);
+    protected <Id> RecordStorage<Id> getStorage(Class<? extends Entity<Id, ?>> entityClass) {
+        return InMemoryRecordStorage.newInstance(false);
     }
 
     @Override
diff --git a/server/src/test/java/org/spine3/server/storage/memory/InMemoryProjectionStorageShould.java b/server/src/test/java/org/spine3/server/storage/memory/InMemoryProjectionStorageShould.java
index 7d740fd652b..82e06cdc657 100644
--- a/server/src/test/java/org/spine3/server/storage/memory/InMemoryProjectionStorageShould.java
+++ b/server/src/test/java/org/spine3/server/storage/memory/InMemoryProjectionStorageShould.java
@@ -32,8 +32,8 @@ public class InMemoryProjectionStorageShould extends ProjectionStorageShould<Str
 
     @Override
     protected ProjectionStorage<String> getStorage() {
-        final InMemoryEntityStorage<String> entityStorage = InMemoryEntityStorage.newInstance(false);
-        final InMemoryProjectionStorage<String> storage = InMemoryProjectionStorage.newInstance(entityStorage, false);
+        final InMemoryRecordStorage<String> recordStorage = InMemoryRecordStorage.newInstance(false);
+        final InMemoryProjectionStorage<String> storage = InMemoryProjectionStorage.newInstance(recordStorage, false);
         return storage;
     }
 
diff --git a/server/src/test/java/org/spine3/server/storage/memory/InMemoryRecordStorageShould.java b/server/src/test/java/org/spine3/server/storage/memory/InMemoryRecordStorageShould.java
new file mode 100644
index 00000000000..ad4d421681d
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/storage/memory/InMemoryRecordStorageShould.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.storage.memory;
+
+import org.spine3.server.storage.RecordStorage;
+import org.spine3.server.storage.RecordStorageShould;
+
+/**
+ * @author Dmytro Dashenkov
+ */
+public class InMemoryRecordStorageShould extends RecordStorageShould {
+
+    @Override
+    protected <T> RecordStorage<T> createStorage() {
+        return InMemoryRecordStorage.newInstance(false);
+    }
+}
diff --git a/server/src/test/java/org/spine3/server/storage/memory/InMemoryStandStorageShould.java b/server/src/test/java/org/spine3/server/storage/memory/InMemoryStandStorageShould.java
new file mode 100644
index 00000000000..801816d0e7c
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/storage/memory/InMemoryStandStorageShould.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.spine3.server.storage.memory;
+
+import org.spine3.server.storage.StandStorage;
+import org.spine3.server.storage.StandStorageShould;
+
+/**
+ * @author Dmytro Dashenkov
+ */
+public class InMemoryStandStorageShould extends StandStorageShould {
+
+    @Override
+    protected StandStorage createStorage() {
+        return InMemoryStandStorage.newBuilder()
+                                   .setMultitenant(false)
+                                   .build();
+    }
+}
diff --git a/server/src/test/java/org/spine3/server/transport/GrpcContainerShould.java b/server/src/test/java/org/spine3/server/transport/GrpcContainerShould.java
new file mode 100644
index 00000000000..856cbdb4195
--- /dev/null
+++ b/server/src/test/java/org/spine3/server/transport/GrpcContainerShould.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.server.transport;
+
+import io.grpc.BindableService;
+import io.grpc.Server;
+import io.grpc.ServerServiceDefinition;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.spine3.test.Verify.assertSize;
+
+/**
+ * @author Alex Tymchenko
+ */
+public class GrpcContainerShould {
+    private Server server;
+    private GrpcContainer grpcContainer;
+
+    @Before
+    public void setUp() {
+        final GrpcContainer.Builder builder = GrpcContainer.newBuilder();
+        grpcContainer = spy(builder.build());
+
+        server = mock(Server.class);
+        doReturn(server).when(grpcContainer)
+                        .createGrpcServer();
+    }
+
+    @After
+    public void tearDown() {
+        if (!grpcContainer.isShutdown()) {
+            grpcContainer.shutdown();
+        }
+    }
+
+    @Test
+    public void start_server() throws IOException {
+        grpcContainer.start();
+
+        verify(server).start();
+    }
+
+    @SuppressWarnings("MagicNumber")
+    @Test
+    public void add_and_remove_parameters_from_builder() {
+        final GrpcContainer.Builder builder = GrpcContainer.newBuilder()
+                                                           .setPort(8080)
+                                                           .setPort(60);
+        assertEquals(60, builder.getPort());
+
+        int count = 3;
+        final List<ServerServiceDefinition> definitions = new ArrayList<>(count);
+
+        for (int i = 0; i < count; i++) {
+            final BindableService mockService = mock(BindableService.class);
+            final ServerServiceDefinition mockDefinition = ServerServiceDefinition
+                    .builder(String.format("service-%s", i))
+                    .build();
+            when(mockService.bindService()).thenReturn(mockDefinition);
+            definitions.add(mockDefinition);
+
+            builder.addService(mockService);
+        }
+
+        count--;
+        builder.removeService(definitions.get(count));
+
+        final Set<ServerServiceDefinition> serviceSet = builder.getServices();
+        assertSize(count, serviceSet);
+
+        final GrpcContainer container = builder.build();
+        assertNotNull(container);
+    }
+
+    @Test
+    public void stop_properly_upon_application_shutdown() throws NoSuchFieldException, IllegalAccessException, IOException {
+        final Class<Runtime> runtimeClass = Runtime.class;
+        // Field signature: private static Runtime currentRuntime
+        // Origin class: {@code java.lang.Runtime}.
+        final Field currentRuntimeValue = runtimeClass.getDeclaredField("currentRuntime");
+        currentRuntimeValue.setAccessible(true);
+        final Runtime runtimeSpy = (Runtime) spy(currentRuntimeValue.get(null));
+        currentRuntimeValue.set(null, runtimeSpy);
+
+        final GrpcContainer container = spy(GrpcContainer.newBuilder()
+                                                         .setPort(8080)
+                                                         .build());
+        container.addShutdownHook();
+        verify(runtimeSpy).addShutdownHook(any(Thread.class));
+
+        container.start();
+        container.getOnShutdownCallback()
+                 .run();
+        verify(container).shutdown();
+    }
+
+    @Test
+    public void throw_exception_if_started_already() throws IOException {
+        grpcContainer.start();
+        try {
+            grpcContainer.start();
+        } catch (IllegalStateException expected) {
+            return;
+        }
+        fail("Exception must be thrown.");
+    }
+
+    @Test
+    public void await_termination() throws IOException, InterruptedException {
+        grpcContainer.start();
+        grpcContainer.awaitTermination();
+
+        verify(server).awaitTermination();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void throw_exception_if_call_await_termination_on_not_started_service() {
+        grpcContainer.awaitTermination();
+    }
+
+    @Test
+    public void assure_service_is_shutdown() throws IOException {
+        grpcContainer.start();
+        grpcContainer.shutdown();
+
+        assertTrue(grpcContainer.isShutdown());
+    }
+
+    @Test
+    public void assure_service_was_not_started() throws IOException {
+        assertTrue(grpcContainer.isShutdown());
+    }
+
+    @Test
+    public void assure_service_is_not_shut_down() throws IOException {
+        grpcContainer.start();
+
+        assertFalse(grpcContainer.isShutdown());
+    }
+
+    @Test
+    public void shutdown_itself() throws IOException, InterruptedException {
+        grpcContainer.start();
+        grpcContainer.shutdown();
+
+        verify(server).shutdown();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void throw_exception_if_call_shutdown_on_not_started_service() {
+        grpcContainer.shutdown();
+    }
+
+    @Test
+    public void throw_exception_if_shutdown_already() throws IOException {
+        grpcContainer.start();
+        grpcContainer.shutdown();
+        try {
+            grpcContainer.shutdown();
+        } catch (IllegalStateException expected) {
+            return;
+        }
+        fail("Expected an exception.");
+    }
+
+}
diff --git a/server/src/test/java/org/spine3/testdata/TestBoundedContextFactory.java b/server/src/test/java/org/spine3/testdata/TestBoundedContextFactory.java
index abc18805668..03272f18dba 100644
--- a/server/src/test/java/org/spine3/testdata/TestBoundedContextFactory.java
+++ b/server/src/test/java/org/spine3/testdata/TestBoundedContextFactory.java
@@ -24,6 +24,7 @@
 import org.spine3.server.command.CommandBus;
 import org.spine3.server.event.EventBus;
 import org.spine3.server.event.enrich.EventEnricher;
+import org.spine3.server.stand.Stand;
 import org.spine3.server.storage.StorageFactory;
 import org.spine3.server.storage.memory.InMemoryStorageFactory;
 
@@ -62,6 +63,13 @@ public static BoundedContext newBoundedContext(EventBus eventBus) {
         return builder.build();
     }
 
+    public static BoundedContext newBoundedContext(Stand stand) {
+        final BoundedContext.Builder builder = BoundedContext.newBuilder()
+                                                             .setStorageFactory(FACTORY)
+                                                             .setStand(stand);
+        return builder.build();
+    }
+
     public static BoundedContext newBoundedContext(CommandBus commandBus) {
         final BoundedContext.Builder builder = BoundedContext.newBuilder()
                                                              .setStorageFactory(FACTORY)
@@ -77,5 +85,14 @@ public static BoundedContext newBoundedContext(CommandBus commandBus, EventBus e
         return builder.build();
     }
 
+    public static BoundedContext newBoundedContext(String name, Stand stand) {
+        final BoundedContext.Builder builder = BoundedContext.newBuilder()
+                             .setStand(stand)
+                             .setName(name)
+                             .setStorageFactory(FACTORY);
+
+        return builder.build();
+    }
+
     private TestBoundedContextFactory() {}
 }
diff --git a/server/src/test/java/org/spine3/testdata/TestStandFactory.java b/server/src/test/java/org/spine3/testdata/TestStandFactory.java
new file mode 100644
index 00000000000..afeed42daee
--- /dev/null
+++ b/server/src/test/java/org/spine3/testdata/TestStandFactory.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2016, TeamDev Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.spine3.testdata;
+
+import org.mockito.Mockito;
+import org.spine3.server.stand.Stand;
+
+/**
+ * Creates stands for tests.
+ *
+ * @author Alex Tymchenko
+ */
+@SuppressWarnings("UtilityClass")
+public class TestStandFactory {
+
+    private TestStandFactory() {}
+
+    public static Stand create() {
+        final Stand stand = Stand.newBuilder()
+                                 .build();
+        return stand;
+    }
+
+    public static Stand createMock() {
+        return Mockito.mock(Stand.class);
+    }
+}
diff --git a/server/src/test/proto/spine/test/clientservice/commands.proto b/server/src/test/proto/spine/test/commandservice/commands.proto
similarity index 87%
rename from server/src/test/proto/spine/test/clientservice/commands.proto
rename to server/src/test/proto/spine/test/commandservice/commands.proto
index b4484eefc70..e5bf5c25122 100644
--- a/server/src/test/proto/spine/test/clientservice/commands.proto
+++ b/server/src/test/proto/spine/test/commandservice/commands.proto
@@ -19,15 +19,15 @@
 //
 syntax = "proto3";
 
-package spine.test.clientservice;
+package spine.test.commandservice;
 
 option (type_url_prefix) = "type.spine3.org";
-option java_package="org.spine3.test.clientservice.command";
-option java_outer_classname = "ClientServiceCommandsProto";
+option java_package="org.spine3.test.commandservice.command";
+option java_outer_classname = "CommandServiceCommandsProto";
 option java_multiple_files = true;
 
 import "spine/annotations.proto";
-import "spine/test/clientservice/project.proto";
+import "spine/test/commandservice/project.proto";
 import "spine/base/event.proto";
 
 message CreateProject {
diff --git a/server/src/test/proto/spine/test/clientservice/customer/commands.proto b/server/src/test/proto/spine/test/commandservice/customer/commands.proto
similarity index 91%
rename from server/src/test/proto/spine/test/clientservice/customer/commands.proto
rename to server/src/test/proto/spine/test/commandservice/customer/commands.proto
index 69017f302b4..5d743667d11 100644
--- a/server/src/test/proto/spine/test/clientservice/customer/commands.proto
+++ b/server/src/test/proto/spine/test/commandservice/customer/commands.proto
@@ -19,15 +19,15 @@
 //
 syntax = "proto3";
 
-package spine.test.clientservice.customer;
+package spine.test.commandservice.customer;
 
 option (type_url_prefix) = "type.spine3.org";
-option java_package="org.spine3.test.clientservice.customer.command";
+option java_package="org.spine3.test.commandservice.customer.command";
 option java_outer_classname = "CustomerCommandsProto";
 option java_multiple_files = true;
 
 import "spine/annotations.proto";
-import "spine/test/clientservice/customer/customer.proto";
+import "spine/test/commandservice/customer/customer.proto";
 
 // A request to create a new customer record.
 message CreateCustomer {
@@ -45,4 +45,4 @@ message CreateCustomer {
 message ResetCustomerCounter {
     // This command message does not have field because it's an imperative to the system internals.
     // The scheduling of the command will be set in `CommandContext` of the corresponding command.
-}
\ No newline at end of file
+}
diff --git a/server/src/test/proto/spine/test/clientservice/customer/customer.proto b/server/src/test/proto/spine/test/commandservice/customer/customer.proto
similarity index 89%
rename from server/src/test/proto/spine/test/clientservice/customer/customer.proto
rename to server/src/test/proto/spine/test/commandservice/customer/customer.proto
index adcd0866996..d3731a5ebd9 100644
--- a/server/src/test/proto/spine/test/clientservice/customer/customer.proto
+++ b/server/src/test/proto/spine/test/commandservice/customer/customer.proto
@@ -19,13 +19,13 @@
 //
 syntax = "proto3";
 
-package spine.test.clientservice.customer;
+package spine.test.commandservice.customer;
 
 option (type_url_prefix) = "type.spine3.org";
 option java_generate_equals_and_hash = true;
 option java_multiple_files = true;
 option java_outer_classname = "CustomerProto";
-option java_package = "org.spine3.test.clientservice.customer";
+option java_package = "org.spine3.test.commandservice.customer";
 
 import "spine/annotations.proto";
 import "spine/people/person_name.proto";
@@ -46,4 +46,7 @@ message Customer {
 
     // The name of the customer.
     people.PersonName name = 2;
+
+    // The list of customer's nicknames.
+    repeated people.PersonName nicknames = 3;
 }
diff --git a/server/src/test/proto/spine/test/clientservice/customer/events.proto b/server/src/test/proto/spine/test/commandservice/customer/events.proto
similarity index 88%
rename from server/src/test/proto/spine/test/clientservice/customer/events.proto
rename to server/src/test/proto/spine/test/commandservice/customer/events.proto
index c30c70e88f8..8dc1a7dbc82 100644
--- a/server/src/test/proto/spine/test/clientservice/customer/events.proto
+++ b/server/src/test/proto/spine/test/commandservice/customer/events.proto
@@ -19,15 +19,15 @@
 //
 syntax = "proto3";
 
-package spine.test.clientservice.customer;
+package spine.test.commandservice.customer;
 
 option (type_url_prefix) = "type.spine3.org";
-option java_package="org.spine3.test.clientservice.customer.event";
+option java_package="org.spine3.test.commandservice.customer.event";
 option java_outer_classname = "CustomerEventsProto";
 option java_multiple_files = true;
 
 import "spine/annotations.proto";
-import "spine/test/clientservice/customer/customer.proto";
+import "spine/test/commandservice/customer/customer.proto";
 
 message CustomerCreated {
     CustomerId customer_id = 1;
diff --git a/server/src/test/proto/spine/test/clientservice/events.proto b/server/src/test/proto/spine/test/commandservice/events.proto
similarity index 86%
rename from server/src/test/proto/spine/test/clientservice/events.proto
rename to server/src/test/proto/spine/test/commandservice/events.proto
index 2d41bbc76a1..3e567289fdb 100644
--- a/server/src/test/proto/spine/test/clientservice/events.proto
+++ b/server/src/test/proto/spine/test/commandservice/events.proto
@@ -19,15 +19,15 @@
 //
 syntax = "proto3";
 
-package spine.test.clientservice;
+package spine.test.commandservice;
 
 option (type_url_prefix) = "type.spine3.org";
-option java_package="org.spine3.test.clientservice.event";
-option java_outer_classname = "ClientServiceEventsProto";
+option java_package="org.spine3.test.commandservice.event";
+option java_outer_classname = "CommandServiceEventsProto";
 option java_multiple_files = true;
 
 import "spine/annotations.proto";
-import "spine/test/clientservice/project.proto";
+import "spine/test/commandservice/project.proto";
 
 message ProjectCreated {
     ProjectId project_id = 1;
diff --git a/server/src/test/proto/spine/test/clientservice/project.proto b/server/src/test/proto/spine/test/commandservice/project.proto
similarity index 94%
rename from server/src/test/proto/spine/test/clientservice/project.proto
rename to server/src/test/proto/spine/test/commandservice/project.proto
index 608d36631e9..858ef60128b 100644
--- a/server/src/test/proto/spine/test/clientservice/project.proto
+++ b/server/src/test/proto/spine/test/commandservice/project.proto
@@ -19,10 +19,10 @@
 //
 syntax = "proto3";
 
-package spine.test.clientservice;
+package spine.test.commandservice;
 
 option (type_url_prefix) = "type.spine3.org";
-option java_package="org.spine3.test.clientservice";
+option java_package="org.spine3.test.commandservice";
 option java_multiple_files = true;
 
 import "spine/annotations.proto";
diff --git a/testutil/src/main/java/org/spine3/test/Tests.java b/testutil/src/main/java/org/spine3/test/Tests.java
index c700b97d37c..1789f5927ac 100644
--- a/testutil/src/main/java/org/spine3/test/Tests.java
+++ b/testutil/src/main/java/org/spine3/test/Tests.java
@@ -20,6 +20,9 @@
 
 package org.spine3.test;
 
+import com.google.protobuf.Descriptors;
+import com.google.protobuf.FieldMask;
+import com.google.protobuf.Message;
 import com.google.protobuf.Timestamp;
 import org.spine3.base.Identifiers;
 import org.spine3.protobuf.Timestamps;
@@ -27,8 +30,10 @@
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
+import java.util.List;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static org.junit.Assert.assertEquals;
 
 /**
  * Utilities for testing.
@@ -122,6 +127,18 @@ public static UserId newUserUuid() {
         return newUserId(Identifiers.newUuid());
     }
 
+    public static void assertMatchesMask(Message message, FieldMask fieldMask) {
+        final List<String> paths = fieldMask.getPathsList();
+
+        for (Descriptors.FieldDescriptor field : message.getDescriptorForType()
+                                                      .getFields()) {
+            if (field.isRepeated()) {
+                continue;
+            }
+            assertEquals(message.hasField(field), paths.contains(field.getFullName()));
+        }
+    }
+
     /** The provider of current time, which is always the same. */
     public static class FrozenMadHatterParty implements Timestamps.Provider {
         private final Timestamp frozenTime;