diff --git a/FbsKerbydata.mon b/FbsKerbydata.mon
new file mode 100644
index 0000000..355dd76
--- /dev/null
+++ b/FbsKerbydata.mon
Binary files differ
diff --git a/kerby-backend/flatbuffers-backend/CodeGen.sh b/kerby-backend/flatbuffers-backend/CodeGen.sh
new file mode 100644
index 0000000..aa4ece6
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/CodeGen.sh
@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# To be refined, considering license headers, formats and etc.
+flatc -j --gen-mutable -o src/main/java src/schema/kerby.fbs
\ No newline at end of file
diff --git a/kerby-backend/flatbuffers-backend/pom.xml b/kerby-backend/flatbuffers-backend/pom.xml
new file mode 100644
index 0000000..772a831
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/pom.xml
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License. See accompanying LICENSE file.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>org.apache.kerby</groupId>
+    <artifactId>kerby-backend</artifactId>
+    <version>1.0.0-RC2-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>flatbuffers-backend</artifactId>
+
+  <name>Flatbuffers identity backend</name>
+  <description>Flatbuffers identity backend</description>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.apache.kerby</groupId>
+      <artifactId>kerby-config</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.kerby</groupId>
+      <artifactId>kerb-identity</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.kerby</groupId>
+      <artifactId>kerb-identity-test</artifactId>
+      <version>${project.version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.google.code.gson</groupId>
+      <artifactId>gson</artifactId>
+      <version>2.3.1</version>
+    </dependency>
+  </dependencies>
+</project>
diff --git a/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/Constants.java b/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/Constants.java
new file mode 100644
index 0000000..67585d7
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/Constants.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.flatbuffers;
+
+// Class that holds shared constants.
+
+public class Constants {
+    // Java doesn't seem to have these.
+    static final int SIZEOF_SHORT = 2;
+    static final int SIZEOF_INT = 4;
+    static final int FILE_IDENTIFIER_LENGTH = 4;
+}
+
diff --git a/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/FlatBufferBuilder.java b/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/FlatBufferBuilder.java
new file mode 100644
index 0000000..368be2f
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/FlatBufferBuilder.java
@@ -0,0 +1,523 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.flatbuffers;
+
+import static com.google.flatbuffers.Constants.*;
+import java.util.Arrays;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Class that helps you build a FlatBuffer.  See the section
+ * <a href="http://google.github.io/flatbuffers/md__java_usage.html">"Use in Java"</a> in the
+ * main FlatBuffers documentation.
+ */
+public class FlatBufferBuilder {
+    ByteBuffer bb;          // Where we construct the FlatBuffer.
+    int space;              // Remaining space in the ByteBuffer.
+    static final Charset utf8charset = Charset.forName("UTF-8");
+    int minalign = 1;       // Minimum alignment encountered so far.
+    int[] vtable = null;    // The vtable for the current table.
+    int vtable_in_use = 0;  // The amount of fields we're actually using.
+    boolean nested = false; // Whether we are currently serializing a table.
+    int object_start;       // Starting offset of the current struct/table.
+    int[] vtables = new int[16];  // List of offsets of all vtables.
+    int num_vtables = 0;          // Number of entries in `vtables` in use.
+    int vector_num_elems = 0;     // For the current vector being built.
+    boolean force_defaults = false; // False omits default values from the serialized data
+
+   /**
+    * Start with a buffer of size {@code initial_size}, then grow as required.
+    *
+    * @param initial_size The initial size of the internal buffer to use
+    */
+    public FlatBufferBuilder(int initial_size) {
+        if (initial_size <= 0) initial_size = 1;
+        space = initial_size;
+        bb = newByteBuffer(initial_size);
+    }
+
+   /**
+    * Start with a buffer of 1KiB, then grow as required.
+    */
+    public FlatBufferBuilder() {
+        this(1024);
+    }
+
+    /**
+     * Alternative constructor allowing reuse of {@link ByteBuffer}s.  The builder
+     * can still grow the buffer as necessary.  User classes should make sure
+     * to call {@link #dataBuffer()} to obtain the resulting encoded message
+     *
+     * @param existing_bb The byte buffer to reuse
+     */
+    public FlatBufferBuilder(ByteBuffer existing_bb) {
+        init(existing_bb);
+    }
+
+    /**
+     * Alternative initializer that allows reusing this object on an existing
+     * ByteBuffer. This method resets the builder's internal state, but keeps
+     * objects that have been allocated for temporary storage.
+     *
+     * @param existing_bb The byte buffer to reuse
+     * @return this
+     */
+    public FlatBufferBuilder init(ByteBuffer existing_bb){
+        bb = existing_bb;
+        bb.clear();
+        bb.order(ByteOrder.LITTLE_ENDIAN);
+        minalign = 1;
+        space = bb.capacity();
+        vtable_in_use = 0;
+        nested = false;
+        object_start = 0;
+        num_vtables = 0;
+        vector_num_elems = 0;
+        return this;
+    }
+
+    static ByteBuffer newByteBuffer(int capacity) {
+        ByteBuffer newbb = ByteBuffer.allocate(capacity);
+        newbb.order(ByteOrder.LITTLE_ENDIAN);
+        return newbb;
+    }
+
+    /**
+     * Doubles the size of the backing {link ByteBuffer} and copies the old data towards the
+     * end of the new buffer (since we build the buffer backwards).
+     *
+     * @param bb The current buffer with the existing data
+     * @return A new byte buffer with the old data copied copied to it.  The data is
+     * located at the end of the buffer.
+     */
+    static ByteBuffer growByteBuffer(ByteBuffer bb) {
+        int old_buf_size = bb.capacity();
+        if ((old_buf_size & 0xC0000000) != 0)  // Ensure we don't grow beyond what fits in an int.
+            throw new AssertionError("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+        int new_buf_size = old_buf_size << 1;
+        bb.position(0);
+        ByteBuffer nbb = newByteBuffer(new_buf_size);
+        nbb.position(new_buf_size - old_buf_size);
+        nbb.put(bb);
+        return nbb;
+    }
+
+   /**
+    * Offset relative to the end of the buffer.
+    *
+    * @return Offset relative to the end of the buffer.
+    */
+    public int offset() {
+        return bb.capacity() - space;
+    }
+
+   /**
+    * Add zero valued bytes to prepare a new entry to be added
+    *
+    * @param byte_size Number of bytes to add.
+    */
+    public void pad(int byte_size) {
+        for (int i = 0; i < byte_size; i++) bb.put(--space, (byte)0);
+    }
+
+   /**
+    * Prepare to write an element of {@code size} after {@code additional_bytes}
+    * have been written, e.g. if you write a string, you need to align such
+    * the int length field is aligned to {@link com.google.flatbuffers.Constants#SIZEOF_INT}, and
+    * the string data follows it directly.  If all you need to do is alignment, {@code additional_bytes}
+    * will be 0.
+    *
+    * @param size This is the of the new element to write
+    * @param additional_bytes The padding size
+    */
+    public void prep(int size, int additional_bytes) {
+        // Track the biggest thing we've ever aligned to.
+        if (size > minalign) minalign = size;
+        // Find the amount of alignment needed such that `size` is properly
+        // aligned after `additional_bytes`
+        int align_size = ((~(bb.capacity() - space + additional_bytes)) + 1) & (size - 1);
+        // Reallocate the buffer if needed.
+        while (space < align_size + size + additional_bytes) {
+            int old_buf_size = bb.capacity();
+            bb = growByteBuffer(bb);
+            space += bb.capacity() - old_buf_size;
+        }
+        pad(align_size);
+    }
+
+    // Add a scalar to the buffer, backwards from the current location.
+    // Doesn't align nor check for space.
+    public void putBoolean(boolean x) { bb.put      (space -= 1, (byte)(x ? 1 : 0)); }
+    public void putByte   (byte    x) { bb.put      (space -= 1, x); }
+    public void putShort  (short   x) { bb.putShort (space -= 2, x); }
+    public void putInt    (int     x) { bb.putInt   (space -= 4, x); }
+    public void putLong   (long    x) { bb.putLong  (space -= 8, x); }
+    public void putFloat  (float   x) { bb.putFloat (space -= 4, x); }
+    public void putDouble (double  x) { bb.putDouble(space -= 8, x); }
+
+    // Adds a scalar to the buffer, properly aligned, and the buffer grown
+    // if needed.
+    public void addBoolean(boolean x) { prep(1, 0); putBoolean(x); }
+    public void addByte   (byte    x) { prep(1, 0); putByte   (x); }
+    public void addShort  (short   x) { prep(2, 0); putShort  (x); }
+    public void addInt    (int     x) { prep(4, 0); putInt    (x); }
+    public void addLong   (long    x) { prep(8, 0); putLong   (x); }
+    public void addFloat  (float   x) { prep(4, 0); putFloat  (x); }
+    public void addDouble (double  x) { prep(8, 0); putDouble (x); }
+
+   /**
+    * Adds on offset, relative to where it will be written.
+    *
+    * @param off The offset to add
+    */
+    public void addOffset(int off) {
+        prep(SIZEOF_INT, 0);  // Ensure alignment is already done.
+        assert off <= offset();
+        off = offset() - off + SIZEOF_INT;
+        putInt(off);
+    }
+
+   /**
+    * Start a new array/vector of objects.  Users usually will not call
+    * this directly.  The {@code FlatBuffers} compiler will create a start/end
+    * method for vector types in generated code.
+    * <p>
+    * The expected sequence of calls is:
+    * <ol>
+    * <li>Start the array using this method.</li>
+    * <li>Call {@link #addOffset(int)} {@code num_elems} number of times to set
+    * the offset of each element in the array.</li>
+    * <li>Call {@link #endVector()} to retrieve the offset of the array.</li>
+    * </ol>
+    * <p>
+    * For example, to create an array of strings, do:
+    * <pre>{@code
+    * // Need 10 strings
+    * FlatBufferBuilder builder = new FlatBufferBuilder(existingBuffer);
+    * int[] offsets = new int[10];
+    *
+    * for (int i = 0; i < 10; i++) {
+    *   offsets[i] = fbb.createString(" " + i);
+    * }
+    *
+    * // Have the strings in the buffer, but don't have a vector.
+    * // Add a vector that references the newly created strings:
+    * builder.startVector(4, offsets.length, 4);
+    *
+    * // Add each string to the newly created vector
+    * // The strings are added in reverse order since the buffer
+    * // is filled in back to front
+    * for (int i = offsets.length - 1; i >= 0; i--) {
+    *   builder.addOffset(offsets[i]);
+    * }
+    *
+    * // Finish off the vector
+    * int offsetOfTheVector = fbb.endVector();
+    * }</pre>
+    *
+    * @param elem_size The size of each element in the array
+    * @param num_elems The number of elements in the array
+    * @param alignment The alignment of the array
+    */
+    public void startVector(int elem_size, int num_elems, int alignment) {
+        notNested();
+        vector_num_elems = num_elems;
+        prep(SIZEOF_INT, elem_size * num_elems);
+        prep(alignment, elem_size * num_elems); // Just in case alignment > int.
+    }
+
+   /**
+    * Finish off the creation of an array and all its elements.  The array
+    * must be created with {@link #startVector(int, int, int)}.
+    *
+    * @return The offset at which the newly created array starts.
+    * @see #startVector(int, int, int)
+    */
+    public int endVector() {
+        putInt(vector_num_elems);
+        return offset();
+    }
+
+   /**
+    * Encode the string {@code s} in the buffer using UTF-8.
+    *
+    * @param s The string to encode
+    * @return The offset in the buffer where the encoded string starts
+    */
+    public int createString(String s) {
+        byte[] utf8 = s.getBytes(utf8charset);
+        addByte((byte)0);
+        startVector(1, utf8.length, 1);
+        bb.position(space -= utf8.length);
+        bb.put(utf8, 0, utf8.length);
+        return endVector();
+    }
+
+   /**
+    * Encode the string {@code s} in the buffer using UTF-8.
+    *
+    * @param s An already encoded UTF-8 string
+    * @return The offset in the buffer where the encoded string starts
+    */
+    public int createString(ByteBuffer s) {
+        int length = s.remaining();
+        addByte((byte)0);
+        startVector(1, length, 1);
+        bb.position(space -= length);
+        bb.put(s);
+        return endVector();
+    }
+
+   /**
+    * Should not be creating any other object, string or vector
+    * while an object is being constructed
+    */
+    public void notNested() {
+        if (nested)
+            throw new AssertionError("FlatBuffers: object serialization must not be nested.");
+    }
+
+   /**
+    * Structures are always stored inline, they need to be created right
+    * where they're used.  You'll get this assertion failure if you
+    * created it elsewhere.
+    *
+    * @param obj The offset of the created object
+    */
+    public void Nested(int obj) {
+        if (obj != offset())
+            throw new AssertionError("FlatBuffers: struct must be serialized inline.");
+    }
+
+   /**
+    * Start encoding a new object in the buffer.  Users will not usually need to
+    * call this directly. The {@code FlatBuffers} compiler will generate helper methods
+    * that call this method internally.
+    * <p>
+    * For example, using the "Monster" code found on the
+    * <a href="http://google.github.io/flatbuffers/md__java_usage.html">landing page</a>. An
+    * object of type {@code Monster} can be created using the following code:
+    *
+    * <pre>{@code
+    * int testArrayOfString = Monster.createTestarrayofstringVector(fbb, new int[] {
+    *   fbb.createString("test1"),
+    *   fbb.createString("test2")
+    * });
+    *
+    * Monster.startMonster(fbb);
+    * Monster.addPos(fbb, Vec3.createVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
+    *   Color.Green, (short)5, (byte)6));
+    * Monster.addHp(fbb, (short)80);
+    * Monster.addName(fbb, str);
+    * Monster.addInventory(fbb, inv);
+    * Monster.addTestType(fbb, (byte)Any.Monster);
+    * Monster.addTest(fbb, mon2);
+    * Monster.addTest4(fbb, test4);
+    * Monster.addTestarrayofstring(fbb, testArrayOfString);
+    * int mon = Monster.endMonster(fbb);
+    * }</pre>
+    * <p>
+    * Here:
+    * <ul>
+    * <li>The call to {@code Monster#startMonster(FlatBufferBuilder)} will call this
+    * method with the right number of fields set.</li>
+    * <li>{@code Monster#endMonster(FlatBufferBuilder)} will ensure {@link #endObject()} is called.</li>
+    * </ul>
+    * <p>
+    * It's not recommended to call this method directly.  If it's called manually, you must ensure
+    * to audit all calls to it whenever fields are added or removed from your schema.  This is
+    * automatically done by the code generated by the {@code FlatBuffers} compiler.
+    *
+    * @param numfields The number of fields found in this object.
+    */
+    public void startObject(int numfields) {
+        notNested();
+        if (vtable == null || vtable.length < numfields) vtable = new int[numfields];
+        vtable_in_use = numfields;
+        Arrays.fill(vtable, 0, vtable_in_use, 0);
+        nested = true;
+        object_start = offset();
+    }
+
+    // Add a scalar to a table at `o` into its vtable, with value `x` and default `d`
+    public void addBoolean(int o, boolean x, boolean d) { if(force_defaults || x != d) { addBoolean(x); slot(o); } }
+    public void addByte   (int o, byte    x, int     d) { if(force_defaults || x != d) { addByte   (x); slot(o); } }
+    public void addShort  (int o, short   x, int     d) { if(force_defaults || x != d) { addShort  (x); slot(o); } }
+    public void addInt    (int o, int     x, int     d) { if(force_defaults || x != d) { addInt    (x); slot(o); } }
+    public void addLong   (int o, long    x, long    d) { if(force_defaults || x != d) { addLong   (x); slot(o); } }
+    public void addFloat  (int o, float   x, double  d) { if(force_defaults || x != d) { addFloat  (x); slot(o); } }
+    public void addDouble (int o, double  x, double  d) { if(force_defaults || x != d) { addDouble (x); slot(o); } }
+    public void addOffset (int o, int     x, int     d) { if(force_defaults || x != d) { addOffset (x); slot(o); } }
+
+    // Structs are stored inline, so nothing additional is being added. `d` is always 0.
+    public void addStruct(int voffset, int x, int d) {
+        if(x != d) {
+            Nested(x);
+            slot(voffset);
+        }
+    }
+
+    // Set the current vtable at `voffset` to the current location in the buffer.
+    public void slot(int voffset) {
+        vtable[voffset] = offset();
+    }
+
+   /**
+    * Finish off writing the object that is under construction.
+    *
+    * @return The offset to the object inside {@link #dataBuffer()}
+    * @see #startObject(int)
+    */
+    public int endObject() {
+        if (vtable == null || !nested)
+            throw new AssertionError("FlatBuffers: endObject called without startObject");
+        addInt(0);
+        int vtableloc = offset();
+        // Write out the current vtable.
+        for (int i = vtable_in_use - 1; i >= 0 ; i--) {
+            // Offset relative to the start of the table.
+            short off = (short)(vtable[i] != 0 ? vtableloc - vtable[i] : 0);
+            addShort(off);
+        }
+
+        final int standard_fields = 2; // The fields below:
+        addShort((short)(vtableloc - object_start));
+        addShort((short)((vtable_in_use + standard_fields) * SIZEOF_SHORT));
+
+        // Search for an existing vtable that matches the current one.
+        int existing_vtable = 0;
+        outer_loop:
+        for (int i = 0; i < num_vtables; i++) {
+            int vt1 = bb.capacity() - vtables[i];
+            int vt2 = space;
+            short len = bb.getShort(vt1);
+            if (len == bb.getShort(vt2)) {
+                for (int j = SIZEOF_SHORT; j < len; j += SIZEOF_SHORT) {
+                    if (bb.getShort(vt1 + j) != bb.getShort(vt2 + j)) {
+                        continue outer_loop;
+                    }
+                }
+                existing_vtable = vtables[i];
+                break outer_loop;
+            }
+        }
+
+        if (existing_vtable != 0) {
+            // Found a match:
+            // Remove the current vtable.
+            space = bb.capacity() - vtableloc;
+            // Point table to existing vtable.
+            bb.putInt(space, existing_vtable - vtableloc);
+        } else {
+            // No match:
+            // Add the location of the current vtable to the list of vtables.
+            if (num_vtables == vtables.length) vtables = Arrays.copyOf(vtables, num_vtables * 2);
+            vtables[num_vtables++] = offset();
+            // Point table to current vtable.
+            bb.putInt(bb.capacity() - vtableloc, offset() - vtableloc);
+        }
+
+        nested = false;
+        return vtableloc;
+    }
+
+    // This checks a required field has been set in a given table that has
+    // just been constructed.
+    public void required(int table, int field) {
+        int table_start = bb.capacity() - table;
+        int vtable_start = table_start - bb.getInt(table_start);
+        boolean ok = bb.getShort(vtable_start + field) != 0;
+        // If this fails, the caller will show what field needs to be set.
+        if (!ok)
+            throw new AssertionError("FlatBuffers: field " + field + " must be set");
+    }
+
+    public void finish(int root_table) {
+        prep(minalign, SIZEOF_INT);
+        addOffset(root_table);
+        bb.position(space);
+    }
+
+    public void finish(int root_table, String file_identifier) {
+        prep(minalign, SIZEOF_INT + FILE_IDENTIFIER_LENGTH);
+        if (file_identifier.length() != FILE_IDENTIFIER_LENGTH)
+            throw new AssertionError("FlatBuffers: file identifier must be length " +
+                                     FILE_IDENTIFIER_LENGTH);
+        for (int i = FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {
+            addByte((byte)file_identifier.charAt(i));
+        }
+        finish(root_table);
+    }
+
+    /**
+     * In order to save space, fields that are set to their default value
+     * don't get serialized into the buffer. Forcing defaults provides a
+     * way to manually disable this optimization.
+     *
+     * @param forceDefaults true always serializes default values
+     * @return this
+     */
+    public FlatBufferBuilder forceDefaults(boolean forceDefaults){
+        this.force_defaults = forceDefaults;
+        return this;
+    }
+
+    // Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+    // called finish(). The actual data starts at the ByteBuffer's current position,
+    // not necessarily at 0.
+    public ByteBuffer dataBuffer() { return bb; }
+
+   /**
+    * The FlatBuffer data doesn't start at offset 0 in the {@link ByteBuffer}, but
+    * now the {@code ByteBuffer}'s position is set to that location upon {@link #finish(int)}.
+    *
+    * @return The {@link ByteBuffer#position() position} the data starts in {@link #dataBuffer()}
+    * @deprecated This method should not be needed anymore, but is left
+    * here for the moment to document this API change. It will be removed in the future.
+    */
+    @Deprecated
+    private int dataStart() {
+        return space;
+    }
+
+   /**
+    * Utility function for copying a byte array from {@code start} to
+    * {@code start} + {@code length}
+    *
+    * @param start Start copying at this offset
+    * @param length How many bytes to copy
+    * @return A range copy of the {@link #dataBuffer() data buffer}
+    * @throws IndexOutOfBoundsException If the range of bytes is ouf of bound
+    */
+    public byte[] sizedByteArray(int start, int length){
+        byte[] array = new byte[length];
+        bb.position(start);
+        bb.get(array);
+        return array;
+    }
+
+   /**
+    * Utility function for copying a byte array that starts at 0.
+    *
+    * @return A full copy of the {@link #dataBuffer() data buffer}
+    */
+    public byte[] sizedByteArray() {
+        return sizedByteArray(space, bb.capacity() - space);
+    }
+}
diff --git a/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/Struct.java b/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/Struct.java
new file mode 100644
index 0000000..9e6fe4a
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/Struct.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.flatbuffers;
+
+import java.nio.ByteBuffer;
+
+// All structs in the generated code derive from this class, and add their own accessors.
+public class Struct {
+  protected int bb_pos;
+  protected ByteBuffer bb;
+}
diff --git a/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/Table.java b/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/Table.java
new file mode 100644
index 0000000..c4a9375
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/main/java/com/google/flatbuffers/Table.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.flatbuffers;
+
+import static com.google.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+// All tables in the generated code derive from this class, and add their own accessors.
+public class Table {
+  protected int bb_pos;
+  protected ByteBuffer bb;
+
+  public ByteBuffer getByteBuffer() { return bb; }
+
+  // Look up a field in the vtable, return an offset into the object, or 0 if the field is not
+  // present.
+  protected int __offset(int vtable_offset) {
+    int vtable = bb_pos - bb.getInt(bb_pos);
+    return vtable_offset < bb.getShort(vtable) ? bb.getShort(vtable + vtable_offset) : 0;
+  }
+
+  // Retrieve the relative offset stored at "offset"
+  protected int __indirect(int offset) {
+    return offset + bb.getInt(offset);
+  }
+
+  // Create a java String from UTF-8 data stored inside the flatbuffer.
+  // This allocates a new string and converts to wide chars upon each access,
+  // which is not very efficient. Instead, each FlatBuffer string also comes with an
+  // accessor based on __vector_as_bytebuffer below, which is much more efficient,
+  // assuming your Java program can handle UTF-8 data directly.
+  protected String __string(int offset) {
+    offset += bb.getInt(offset);
+    if (bb.hasArray()) {
+      return new String(bb.array(), bb.arrayOffset() + offset + SIZEOF_INT, bb.getInt(offset), FlatBufferBuilder.utf8charset);
+    } else {
+      // We can't access .array(), since the ByteBuffer is read-only,
+      // off-heap or a memory map
+      ByteBuffer bb = this.bb.duplicate().order(ByteOrder.LITTLE_ENDIAN);
+      // We're forced to make an extra copy:
+      byte[] copy = new byte[bb.getInt(offset)];
+      bb.position(offset + SIZEOF_INT);
+      bb.get(copy);
+      return new String(copy, 0, copy.length, FlatBufferBuilder.utf8charset);
+    }
+  }
+
+  // Get the length of a vector whose offset is stored at "offset" in this object.
+  protected int __vector_len(int offset) {
+    offset += bb_pos;
+    offset += bb.getInt(offset);
+    return bb.getInt(offset);
+  }
+
+  // Get the start of data of a vector whose offset is stored at "offset" in this object.
+  protected int __vector(int offset) {
+    offset += bb_pos;
+    return offset + bb.getInt(offset) + SIZEOF_INT;  // data starts after the length
+  }
+
+  // Get a whole vector as a ByteBuffer. This is efficient, since it only allocates a new
+  // bytebuffer object, but does not actually copy the data, it still refers to the same
+  // bytes as the original ByteBuffer.
+  // Also useful with nested FlatBuffers etc.
+  protected ByteBuffer __vector_as_bytebuffer(int vector_offset, int elem_size) {
+    int o = __offset(vector_offset);
+    if (o == 0) return null;
+    ByteBuffer bb = this.bb.duplicate().order(ByteOrder.LITTLE_ENDIAN);
+    int vectorstart = __vector(o);
+    bb.position(vectorstart);
+    bb.limit(vectorstart + __vector_len(o) * elem_size);
+    return bb;
+  }
+
+  // Initialize any Table-derived type to point to the union at the given offset.
+  protected Table __union(Table t, int offset) {
+    offset += bb_pos;
+    t.bb_pos = offset + bb.getInt(offset);
+    t.bb = bb;
+    return t;
+  }
+
+  protected static boolean __has_identifier(ByteBuffer bb, String ident) {
+    if (ident.length() != FILE_IDENTIFIER_LENGTH)
+        throw new AssertionError("FlatBuffers: file identifier must be length " +
+                                 FILE_IDENTIFIER_LENGTH);
+    for (int i = 0; i < FILE_IDENTIFIER_LENGTH; i++) {
+      if (ident.charAt(i) != (char)bb.get(bb.position() + SIZEOF_INT + i)) return false;
+    }
+    return true;
+  }
+}
diff --git a/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsEncryptionKey.java b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsEncryptionKey.java
new file mode 100644
index 0000000..3600666
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsEncryptionKey.java
@@ -0,0 +1,42 @@
+// automatically generated, do not modify
+
+package org.apache.kerby.kerberos.kdc.identitybackend;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class FbsEncryptionKey extends Table {
+  public static FbsEncryptionKey getRootAsFbsEncryptionKey(ByteBuffer _bb) { return getRootAsFbsEncryptionKey(_bb, new FbsEncryptionKey()); }
+  public static FbsEncryptionKey getRootAsFbsEncryptionKey(ByteBuffer _bb, FbsEncryptionKey obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public FbsEncryptionKey __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public int keyType() { int o = __offset(4); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
+  public boolean mutateKeyType(int keyType) { int o = __offset(4); if (o != 0) { bb.putInt(o + bb_pos, keyType); return true; } else { return false; } }
+  public byte keyValue(int j) { int o = __offset(6); return o != 0 ? bb.get(__vector(o) + j * 1) : 0; }
+  public int keyValueLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; }
+  public ByteBuffer keyValueAsByteBuffer() { return __vector_as_bytebuffer(6, 1); }
+  public boolean mutateKeyValue(int j, byte keyValue) { int o = __offset(6); if (o != 0) { bb.put(__vector(o) + j * 1, keyValue); return true; } else { return false; } }
+
+  public static int createFbsEncryptionKey(FlatBufferBuilder builder,
+      int keyType,
+      int keyValue) {
+    builder.startObject(2);
+    FbsEncryptionKey.addKeyValue(builder, keyValue);
+    FbsEncryptionKey.addKeyType(builder, keyType);
+    return FbsEncryptionKey.endFbsEncryptionKey(builder);
+  }
+
+  public static void startFbsEncryptionKey(FlatBufferBuilder builder) { builder.startObject(2); }
+  public static void addKeyType(FlatBufferBuilder builder, int keyType) { builder.addInt(0, keyType, 0); }
+  public static void addKeyValue(FlatBufferBuilder builder, int keyValueOffset) { builder.addOffset(1, keyValueOffset, 0); }
+  public static int createKeyValueVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
+  public static void startKeyValueVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
+  public static int endFbsEncryptionKey(FlatBufferBuilder builder) {
+    int o = builder.endObject();
+    return o;
+  }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsKerby.java b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsKerby.java
new file mode 100644
index 0000000..21f8363
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsKerby.java
@@ -0,0 +1,42 @@
+// automatically generated, do not modify
+
+package org.apache.kerby.kerberos.kdc.identitybackend;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class FbsKerby extends Table {
+  public static FbsKerby getRootAsFbsKerby(ByteBuffer _bb) { return getRootAsFbsKerby(_bb, new FbsKerby()); }
+  public static FbsKerby getRootAsFbsKerby(ByteBuffer _bb, FbsKerby obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public FbsKerby __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public String name() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer nameAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+  public FbsKrbIdentity identities(int j) { return identities(new FbsKrbIdentity(), j); }
+  public FbsKrbIdentity identities(FbsKrbIdentity obj, int j) { int o = __offset(6); return o != 0 ? obj.__init(__indirect(__vector(o) + j * 4), bb) : null; }
+  public int identitiesLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; }
+
+  public static int createFbsKerby(FlatBufferBuilder builder,
+      int name,
+      int identities) {
+    builder.startObject(2);
+    FbsKerby.addIdentities(builder, identities);
+    FbsKerby.addName(builder, name);
+    return FbsKerby.endFbsKerby(builder);
+  }
+
+  public static void startFbsKerby(FlatBufferBuilder builder) { builder.startObject(2); }
+  public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(0, nameOffset, 0); }
+  public static void addIdentities(FlatBufferBuilder builder, int identitiesOffset) { builder.addOffset(1, identitiesOffset, 0); }
+  public static int createIdentitiesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startIdentitiesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static int endFbsKerby(FlatBufferBuilder builder) {
+    int o = builder.endObject();
+    return o;
+  }
+  public static void finishFbsKerbyBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset); }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsKrbIdentity.java b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsKrbIdentity.java
new file mode 100644
index 0000000..13a1314
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsKrbIdentity.java
@@ -0,0 +1,56 @@
+// automatically generated, do not modify
+
+package org.apache.kerby.kerberos.kdc.identitybackend;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class FbsKrbIdentity extends Table {
+  public static FbsKrbIdentity getRootAsFbsKrbIdentity(ByteBuffer _bb) { return getRootAsFbsKrbIdentity(_bb, new FbsKrbIdentity()); }
+  public static FbsKrbIdentity getRootAsFbsKrbIdentity(ByteBuffer _bb, FbsKrbIdentity obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public FbsKrbIdentity __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public FbsPrincipalName principal() { return principal(new FbsPrincipalName()); }
+  public FbsPrincipalName principal(FbsPrincipalName obj) { int o = __offset(4); return o != 0 ? obj.__init(__indirect(o + bb_pos), bb) : null; }
+  public int keyVersion() { int o = __offset(6); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
+  public boolean mutateKeyVersion(int keyVersion) { int o = __offset(6); if (o != 0) { bb.putInt(o + bb_pos, keyVersion); return true; } else { return false; } }
+  public int kdcFlags() { int o = __offset(8); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
+  public boolean mutateKdcFlags(int kdcFlags) { int o = __offset(8); if (o != 0) { bb.putInt(o + bb_pos, kdcFlags); return true; } else { return false; } }
+  public boolean disabled() { int o = __offset(10); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+  public boolean mutateDisabled(boolean disabled) { int o = __offset(10); if (o != 0) { bb.put(o + bb_pos, (byte)(disabled ? 1 : 0)); return true; } else { return false; } }
+  public FbsEncryptionKey keys(int j) { return keys(new FbsEncryptionKey(), j); }
+  public FbsEncryptionKey keys(FbsEncryptionKey obj, int j) { int o = __offset(12); return o != 0 ? obj.__init(__indirect(__vector(o) + j * 4), bb) : null; }
+  public int keysLength() { int o = __offset(12); return o != 0 ? __vector_len(o) : 0; }
+
+  public static int createFbsKrbIdentity(FlatBufferBuilder builder,
+      int principal,
+      int keyVersion,
+      int kdcFlags,
+      boolean disabled,
+      int keys) {
+    builder.startObject(5);
+    FbsKrbIdentity.addKeys(builder, keys);
+    FbsKrbIdentity.addKdcFlags(builder, kdcFlags);
+    FbsKrbIdentity.addKeyVersion(builder, keyVersion);
+    FbsKrbIdentity.addPrincipal(builder, principal);
+    FbsKrbIdentity.addDisabled(builder, disabled);
+    return FbsKrbIdentity.endFbsKrbIdentity(builder);
+  }
+
+  public static void startFbsKrbIdentity(FlatBufferBuilder builder) { builder.startObject(5); }
+  public static void addPrincipal(FlatBufferBuilder builder, int principalOffset) { builder.addOffset(0, principalOffset, 0); }
+  public static void addKeyVersion(FlatBufferBuilder builder, int keyVersion) { builder.addInt(1, keyVersion, 0); }
+  public static void addKdcFlags(FlatBufferBuilder builder, int kdcFlags) { builder.addInt(2, kdcFlags, 0); }
+  public static void addDisabled(FlatBufferBuilder builder, boolean disabled) { builder.addBoolean(3, disabled, false); }
+  public static void addKeys(FlatBufferBuilder builder, int keysOffset) { builder.addOffset(4, keysOffset, 0); }
+  public static int createKeysVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startKeysVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static int endFbsKrbIdentity(FlatBufferBuilder builder) {
+    int o = builder.endObject();
+    return o;
+  }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsPrincipalName.java b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsPrincipalName.java
new file mode 100644
index 0000000..baef55c
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FbsPrincipalName.java
@@ -0,0 +1,38 @@
+// automatically generated, do not modify
+
+package org.apache.kerby.kerberos.kdc.identitybackend;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class FbsPrincipalName extends Table {
+  public static FbsPrincipalName getRootAsFbsPrincipalName(ByteBuffer _bb) { return getRootAsFbsPrincipalName(_bb, new FbsPrincipalName()); }
+  public static FbsPrincipalName getRootAsFbsPrincipalName(ByteBuffer _bb, FbsPrincipalName obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public FbsPrincipalName __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public int nameType() { int o = __offset(4); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
+  public boolean mutateNameType(int nameType) { int o = __offset(4); if (o != 0) { bb.putInt(o + bb_pos, nameType); return true; } else { return false; } }
+  public String nameString() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer nameStringAsByteBuffer() { return __vector_as_bytebuffer(6, 1); }
+
+  public static int createFbsPrincipalName(FlatBufferBuilder builder,
+      int nameType,
+      int nameString) {
+    builder.startObject(2);
+    FbsPrincipalName.addNameString(builder, nameString);
+    FbsPrincipalName.addNameType(builder, nameType);
+    return FbsPrincipalName.endFbsPrincipalName(builder);
+  }
+
+  public static void startFbsPrincipalName(FlatBufferBuilder builder) { builder.startObject(2); }
+  public static void addNameType(FlatBufferBuilder builder, int nameType) { builder.addInt(0, nameType, 0); }
+  public static void addNameString(FlatBufferBuilder builder, int nameStringOffset) { builder.addOffset(1, nameStringOffset, 0); }
+  public static int endFbsPrincipalName(FlatBufferBuilder builder) {
+    int o = builder.endObject();
+    return o;
+  }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FlatbuffersIdentityBackend.java b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FlatbuffersIdentityBackend.java
new file mode 100644
index 0000000..57c8bc4
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/main/java/org/apache/kerby/kerberos/kdc/identitybackend/FlatbuffersIdentityBackend.java
@@ -0,0 +1,197 @@
+/**
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License. 
+ *
+ */
+package org.apache.kerby.kerberos.kdc.identitybackend;
+
+import com.google.flatbuffers.FlatBufferBuilder;
+import org.apache.kerby.config.Config;
+import org.apache.kerby.kerberos.kerb.KrbException;
+import org.apache.kerby.kerberos.kerb.identity.KrbIdentity;
+import org.apache.kerby.kerberos.kerb.identity.backend.AbstractIdentityBackend;
+import org.apache.kerby.util.IOUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A Flatbuffers backed backend implementation.
+ *
+ */
+public class FlatbuffersIdentityBackend extends AbstractIdentityBackend {
+    private static final Logger LOG =
+            LoggerFactory.getLogger(FlatbuffersIdentityBackend.class);
+    public static final String FBS_IDENTITY_BACKEND_DIR =
+            "backend.flatbuffers.dir";
+    private File fbsKdbFile;
+    private FlatBufferBuilder fbsBuilder;
+    private long kdbFileTimeStamp;
+
+    // Identities loaded from file
+    private final Map<String, KrbIdentity> identities =
+        new ConcurrentHashMap<>(new TreeMap<String, KrbIdentity>());
+
+    public FlatbuffersIdentityBackend() {
+
+    }
+
+    /**
+     * Constructing an instance using specified config that contains anything
+     * to be used to initialize the fbs format database.
+     * @param config The configuration for fbs identity backend
+     */
+    public FlatbuffersIdentityBackend(Config config) {
+        setConfig(config);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void doInitialize() throws KrbException {
+        LOG.info("Initializing the Flatbuffers identity backend.");
+        createFbsBuilder();
+        load();
+    }
+
+    /**
+     * Load identities from file
+     */
+    private void load() throws KrbException {
+        LOG.info("Loading the identities from fbs file.");
+        String fbsFile = getConfig().getString(FBS_IDENTITY_BACKEND_DIR);
+        File fbsFileDir;
+        if (fbsFile == null || fbsFile.isEmpty()) {
+            fbsFileDir = getBackendConfig().getConfDir();
+        } else {
+            fbsFileDir = new File(fbsFile);
+            if (!fbsFileDir.exists() && !fbsFileDir.mkdirs()) {
+                throw new KrbException("could not create fbs file dir " + fbsFileDir);
+            }
+        }
+
+        fbsKdbFile = new File(fbsFileDir, "fbs-backend.bin");
+
+        if (!fbsKdbFile.exists()) {
+            try {
+                fbsKdbFile.createNewFile();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        checkAndLoad();
+    }
+
+    /**
+     * Check kdb file timestamp to see if it's changed or not. If
+     * necessary load the kdb again.
+     */
+    private synchronized void checkAndLoad() throws KrbException {
+        long nowTimeStamp = fbsKdbFile.lastModified();
+
+        if (kdbFileTimeStamp == 0 || nowTimeStamp != kdbFileTimeStamp) {
+            //load identities
+            String existsFbsFile = null;
+            try {
+                existsFbsFile = IOUtil.readFile(fbsKdbFile);
+            } catch (IOException e) {
+                throw new KrbException("Failed to read file", e);
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected KrbIdentity doGetIdentity(String principalName) throws KrbException {
+        checkAndLoad();
+        return identities.get(principalName);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected KrbIdentity doAddIdentity(KrbIdentity identity) throws KrbException {
+        checkAndLoad();
+
+        identities.put(identity.getPrincipalName(), identity);
+        idsToFile(identities);
+
+        return doGetIdentity(identity.getPrincipalName());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected KrbIdentity doUpdateIdentity(KrbIdentity identity) throws KrbException {
+        checkAndLoad();
+        identities.put(identity.getPrincipalName(), identity);
+        idsToFile(identities);
+
+        return doGetIdentity(identity.getPrincipalName());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected void doDeleteIdentity(String principalName) throws KrbException {
+        checkAndLoad();
+        if (identities.containsKey(principalName)) {
+            identities.remove(principalName);
+        }
+        idsToFile(identities);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    protected Iterable<String> doGetIdentities() throws KrbException {
+        List<String> principals = new ArrayList<>(identities.keySet());
+        Collections.sort(principals);
+
+        return principals;
+    }
+
+    private void createFbsBuilder() {
+        fbsBuilder = new FlatBufferBuilder();
+    }
+
+    /**
+     * Write identities into a file
+     * @param ids the identities to write into the fbs file
+     */
+    private synchronized void idsToFile(Map<String, KrbIdentity> ids) throws KrbException {
+        String newFbsFile = null;
+        try {
+            IOUtil.writeFile(newFbsFile, fbsKdbFile);
+        } catch (IOException e) {
+            LOG.error("Error occurred while writing identities to file: " + fbsKdbFile);
+            throw new KrbException("Failed to write file", e);
+        }
+    }
+}
diff --git a/kerby-backend/flatbuffers-backend/src/schema/include_test1.fbs b/kerby-backend/flatbuffers-backend/src/schema/include_test1.fbs
new file mode 100644
index 0000000..11aebe8
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/schema/include_test1.fbs
@@ -0,0 +1,5 @@
+include "include_test2.fbs";
+include "include_test2.fbs";  // should be skipped
+include "include_test1.fbs";  // should be skipped
+
+
diff --git a/kerby-backend/flatbuffers-backend/src/schema/include_test2.fbs b/kerby-backend/flatbuffers-backend/src/schema/include_test2.fbs
new file mode 100644
index 0000000..d22c0d9
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/schema/include_test2.fbs
@@ -0,0 +1,9 @@
+include "include_test2.fbs";    // should be skipped
+
+namespace MyGame.OtherNameSpace;
+
+enum FromInclude:long { IncludeVal }
+
+struct Unused {}
+
+
diff --git a/kerby-backend/flatbuffers-backend/src/schema/kerby.fbs b/kerby-backend/flatbuffers-backend/src/schema/kerby.fbs
new file mode 100644
index 0000000..a4eea19
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/schema/kerby.fbs
@@ -0,0 +1,28 @@
+// Kerby KDC backend schema file
+
+namespace org.apache.kerby.kerberos.kdc.identitybackend;
+
+table FbsPrincipalName {
+  nameType:int;
+  nameString:string;
+}
+
+table FbsEncryptionKey {
+  keyType:int;
+  keyValue:[byte];
+}
+
+table FbsKrbIdentity {
+  principal:FbsPrincipalName;
+  keyVersion:int;
+  kdcFlags:int;
+  disabled:bool;
+  keys:[FbsEncryptionKey];
+}
+
+table FbsKerby {
+  name:string;
+  identities:[FbsKrbIdentity];
+}
+
+root_type FbsKerby;
\ No newline at end of file
diff --git a/kerby-backend/flatbuffers-backend/src/schema/monster_test.fbs b/kerby-backend/flatbuffers-backend/src/schema/monster_test.fbs
new file mode 100644
index 0000000..b2b99bb
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/schema/monster_test.fbs
@@ -0,0 +1,66 @@
+// test schema file
+
+include "include_test1.fbs";
+
+namespace MyGame.Example;
+
+attribute "priority";
+
+enum Color:byte (bit_flags) { Red = 0, Green, Blue = 3, }
+
+union Any { Monster, TestSimpleTableWithEnum }  // TODO: add more elements
+
+struct Test { a:short; b:byte; }
+
+table TestSimpleTableWithEnum {
+  color: Color = Green;
+}
+
+struct Vec3 (force_align: 16) {
+  x:float;
+  y:float;
+  z:float;
+  test1:double;
+  test2:Color;
+  test3:Test;
+}
+
+table Stat {
+  id:string;
+  val:long;
+  count:ushort;
+}
+
+table Monster {
+  pos:Vec3 (id: 0);
+  hp:short = 100 (id: 2);
+  mana:short = 150 (id: 1);
+  name:string (id: 3, required, key);
+  color:Color = Blue (id: 6);
+  inventory:[ubyte] (id: 5);
+  friendly:bool = false (deprecated, priority: 1, id: 4);
+  /// an example documentation comment: this will end up in the generated code
+  /// multiline too
+  testarrayoftables:[Monster] (id: 11);
+  testarrayofstring:[string] (id: 10);
+  testarrayofbools:[bool] (id: 24);
+  enemy:MyGame.Example.Monster (id:12);  // Test referring by full namespace.
+  test:Any (id: 8);
+  test4:[Test] (id: 9);
+  testnestedflatbuffer:[ubyte] (id:13, nested_flatbuffer: "Monster");
+  testempty:Stat (id:14);
+  testbool:bool (id:15);
+  testhashs32_fnv1:int (id:16, hash:"fnv1_32");
+  testhashu32_fnv1:uint (id:17, hash:"fnv1_32");
+  testhashs64_fnv1:long (id:18, hash:"fnv1_64");
+  testhashu64_fnv1:ulong (id:19, hash:"fnv1_64");
+  testhashs32_fnv1a:int (id:20, hash:"fnv1a_32");
+  testhashu32_fnv1a:uint (id:21, hash:"fnv1a_32");
+  testhashs64_fnv1a:long (id:22, hash:"fnv1a_64");
+  testhashu64_fnv1a:ulong (id:23, hash:"fnv1a_64");
+}
+
+root_type Monster;
+
+file_identifier "MONS";
+file_extension "mon";
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/JavaTest.java b/kerby-backend/flatbuffers-backend/src/test/java/JavaTest.java
new file mode 100644
index 0000000..936bca5
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/JavaTest.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.*;
+import java.nio.ByteBuffer;
+import MyGame.Example.*;
+import com.google.flatbuffers.FlatBufferBuilder;
+
+class JavaTest {
+    public static void main(String[] args) {
+
+        // First, let's test reading a FlatBuffer generated by C++ code:
+        // This file was generated from monsterdata_test.json
+
+        byte[] data = null;
+        File file = new File("C:\\work\\projects\\kerby\\kerby-backend\\flatbuffers-backend\\src\\test\\monsterdata_test.mon");
+        RandomAccessFile f = null;
+        try {
+            f = new RandomAccessFile(file, "r");
+            data = new byte[(int)f.length()];
+            f.readFully(data);
+            f.close();
+        } catch(IOException e) {
+            System.out.println("FlatBuffers test: couldn't read file");
+            return;
+        }
+
+        // Now test it:
+
+        ByteBuffer bb = ByteBuffer.wrap(data);
+        TestBuffer(bb);
+
+        FlatBufferBuilder fbb = new FlatBufferBuilder(1);
+
+        // We set up the same values as monsterdata.json:
+
+        int str = fbb.createString("MyMonster");
+        // Second, let's create a FlatBuffer from scratch in Java, and test it also.
+        // We use an initial size of 1 to exercise the reallocation algorithm,
+        // normally a size larger than the typical FlatBuffer you generate would be
+        // better for performance.
+
+        int inv = Monster.createInventoryVector(fbb, new byte[] { 0, 1, 2, 3, 4 });
+
+        int fred = fbb.createString("Fred");
+        Monster.startMonster(fbb);
+        Monster.addName(fbb, fred);
+        int mon2 = Monster.endMonster(fbb);
+
+        Monster.startTest4Vector(fbb, 2);
+        Test.createTest(fbb, (short)10, (byte)20);
+        Test.createTest(fbb, (short)30, (byte)40);
+        int test4 = fbb.endVector();
+
+        int testArrayOfString = Monster.createTestarrayofstringVector(fbb, new int[] {
+            fbb.createString("test1"),
+            fbb.createString("test2")
+        });
+
+        Monster.startMonster(fbb);
+        Monster.addPos(fbb, Vec3.createVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
+                                                 Color.Green, (short)5, (byte)6));
+        Monster.addHp(fbb, (short)80);
+        Monster.addName(fbb, str);
+        Monster.addInventory(fbb, inv);
+        Monster.addTestType(fbb, (byte)Any.Monster);
+        Monster.addTest(fbb, mon2);
+        Monster.addTest4(fbb, test4);
+        Monster.addTestarrayofstring(fbb, testArrayOfString);
+        Monster.addTestbool(fbb, false);
+        Monster.addTesthashu32Fnv1(fbb, Integer.MAX_VALUE + 1L);
+        int mon = Monster.endMonster(fbb);
+
+        Monster.finishMonsterBuffer(fbb, mon);
+
+        // Write the result to a file for debugging purposes:
+        // Note that the binaries are not necessarily identical, since the JSON
+        // parser may serialize in a slightly different order than the above
+        // Java code. They are functionally equivalent though.
+
+        try {
+            DataOutputStream os = new DataOutputStream(new FileOutputStream(
+                                           "monsterdata_java_wire.mon"));
+            os.write(fbb.dataBuffer().array(), fbb.dataBuffer().position(), fbb.offset());
+            os.close();
+        } catch(IOException e) {
+            System.out.println("FlatBuffers test: couldn't write file");
+            return;
+        }
+
+        // Test it:
+        TestExtendedBuffer(fbb.dataBuffer());
+
+        // Make sure it also works with read only ByteBuffers. This is slower,
+        // since creating strings incurs an additional copy
+        // (see Table.__string).
+        TestExtendedBuffer(fbb.dataBuffer().asReadOnlyBuffer());
+
+        TestEnums();
+
+        //Attempt to mutate Monster fields and check whether the buffer has been mutated properly
+        // revert to original values after testing
+        Monster monster = Monster.getRootAsMonster(fbb.dataBuffer());
+
+        // mana is optional and does not exist in the buffer so the mutation should fail
+        // the mana field should retain its default value
+        TestEq(monster.mutateMana((short)10), false);
+        TestEq(monster.mana(), (short)150);
+
+        // testType is an existing field and mutating it should succeed
+        TestEq(monster.testType(), (byte)Any.Monster);
+        TestEq(monster.mutateTestType(Any.NONE), true);
+        TestEq(monster.testType(), (byte)Any.NONE);
+        TestEq(monster.mutateTestType(Any.Monster), true);
+        TestEq(monster.testType(), (byte)Any.Monster);
+
+        //mutate the inventory vector
+        TestEq(monster.mutateInventory(0, 1), true);
+        TestEq(monster.mutateInventory(1, 2), true);
+        TestEq(monster.mutateInventory(2, 3), true);
+        TestEq(monster.mutateInventory(3, 4), true);
+        TestEq(monster.mutateInventory(4, 5), true);
+
+        for (int i = 0; i < monster.inventoryLength(); i++) {
+            TestEq(monster.inventory(i), i + 1);
+        }
+
+        //reverse mutation
+        TestEq(monster.mutateInventory(0, 0), true);
+        TestEq(monster.mutateInventory(1, 1), true);
+        TestEq(monster.mutateInventory(2, 2), true);
+        TestEq(monster.mutateInventory(3, 3), true);
+        TestEq(monster.mutateInventory(4, 4), true);
+
+        // get a struct field and edit one of its fields
+        Vec3 pos = monster.pos();
+        TestEq(pos.x(), 1.0f);
+        pos.mutateX(55.0f);
+        TestEq(pos.x(), 55.0f);
+        pos.mutateX(1.0f);
+        TestEq(pos.x(), 1.0f);
+
+        TestExtendedBuffer(fbb.dataBuffer().asReadOnlyBuffer());
+
+        System.out.println("FlatBuffers test: completed successfully");
+    }
+
+    static void TestEnums() {
+      TestEq(Color.name(Color.Red), "Red");
+      TestEq(Color.name(Color.Blue), "Blue");
+      TestEq(Any.name(Any.NONE), "NONE");
+      TestEq(Any.name(Any.Monster), "Monster");
+    }
+
+    static void TestBuffer(ByteBuffer bb) {
+        TestEq(Monster.MonsterBufferHasIdentifier(bb), true);
+        
+        Monster monster = Monster.getRootAsMonster(bb);
+
+        TestEq(monster.hp(), (short)80);
+        TestEq(monster.mana(), (short)150);  // default
+
+        TestEq(monster.name(), "MyMonster");
+        // monster.friendly() // can't access, deprecated
+
+        Vec3 pos = monster.pos();
+        TestEq(pos.x(), 1.0f);
+        TestEq(pos.y(), 2.0f);
+        TestEq(pos.z(), 3.0f);
+        TestEq(pos.test1(), 3.0);
+        TestEq(pos.test2(), Color.Green);
+        Test t = pos.test3();
+        TestEq(t.a(), (short)5);
+        TestEq(t.b(), (byte)6);
+
+        TestEq(monster.testType(), (byte)Any.Monster);
+        Monster monster2 = new Monster();
+        TestEq(monster.test(monster2) != null, true);
+        TestEq(monster2.name(), "Fred");
+
+        TestEq(monster.inventoryLength(), 5);
+        int invsum = 0;
+        for (int i = 0; i < monster.inventoryLength(); i++)
+            invsum += monster.inventory(i);
+        TestEq(invsum, 10);
+
+        // Alternative way of accessing a vector:
+        ByteBuffer ibb = monster.inventoryAsByteBuffer();
+        invsum = 0;
+        while (ibb.position() < ibb.limit())
+            invsum += ibb.get();
+        TestEq(invsum, 10);
+
+        Test test_0 = monster.test4(0);
+        Test test_1 = monster.test4(1);
+        TestEq(monster.test4Length(), 2);
+        TestEq(test_0.a() + test_0.b() + test_1.a() + test_1.b(), 100);
+
+        TestEq(monster.testarrayofstringLength(), 2);
+        TestEq(monster.testarrayofstring(0),"test1");
+        TestEq(monster.testarrayofstring(1),"test2");
+
+        TestEq(monster.testbool(), false);
+    }
+
+    // this method checks additional fields not present in the binary buffer read from file
+    // these new tests are performed on top of the regular tests
+    static void TestExtendedBuffer(ByteBuffer bb) {
+        TestBuffer(bb);
+
+        Monster monster = Monster.getRootAsMonster(bb);
+
+        TestEq(monster.testhashu32Fnv1(), Integer.MAX_VALUE + 1L);
+    }
+
+    static <T> void TestEq(T a, T b) {
+        if (!a.equals(b)) {
+            System.out.println("" + a.getClass().getName() + " " + b.getClass().getName());
+            System.out.println("FlatBuffers test FAILED: \'" + a + "\' != \'" + b + "\'");
+            assert false;
+            System.exit(1);
+        }
+    }
+}
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Any.java b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Any.java
new file mode 100644
index 0000000..cdc3ec5
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Any.java
@@ -0,0 +1,15 @@
+// automatically generated, do not modify
+
+package MyGame.Example;
+
+public final class Any {
+  private Any() { }
+  public static final byte NONE = 0;
+  public static final byte Monster = 1;
+  public static final byte TestSimpleTableWithEnum = 2;
+
+  private static final String[] names = { "NONE", "Monster", "TestSimpleTableWithEnum", };
+
+  public static String name(int e) { return names[e]; }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Color.java b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Color.java
new file mode 100644
index 0000000..822d2bb
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Color.java
@@ -0,0 +1,15 @@
+// automatically generated, do not modify
+
+package MyGame.Example;
+
+public final class Color {
+  private Color() { }
+  public static final byte Red = 1;
+  public static final byte Green = 2;
+  public static final byte Blue = 8;
+
+  private static final String[] names = { "Red", "Green", "", "", "", "", "", "Blue", };
+
+  public static String name(int e) { return names[e - Red]; }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Monster.java b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Monster.java
new file mode 100644
index 0000000..9f97590
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Monster.java
@@ -0,0 +1,120 @@
+// automatically generated, do not modify
+
+package MyGame.Example;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class Monster extends Table {
+  public static Monster getRootAsMonster(ByteBuffer _bb) { return getRootAsMonster(_bb, new Monster()); }
+  public static Monster getRootAsMonster(ByteBuffer _bb, Monster obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public static boolean MonsterBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "MONS"); }
+  public Monster __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public Vec3 pos() { return pos(new Vec3()); }
+  public Vec3 pos(Vec3 obj) { int o = __offset(4); return o != 0 ? obj.__init(o + bb_pos, bb) : null; }
+  public short mana() { int o = __offset(6); return o != 0 ? bb.getShort(o + bb_pos) : 150; }
+  public boolean mutateMana(short mana) { int o = __offset(6); if (o != 0) { bb.putShort(o + bb_pos, mana); return true; } else { return false; } }
+  public short hp() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) : 100; }
+  public boolean mutateHp(short hp) { int o = __offset(8); if (o != 0) { bb.putShort(o + bb_pos, hp); return true; } else { return false; } }
+  public String name() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer nameAsByteBuffer() { return __vector_as_bytebuffer(10, 1); }
+  public int inventory(int j) { int o = __offset(14); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
+  public int inventoryLength() { int o = __offset(14); return o != 0 ? __vector_len(o) : 0; }
+  public ByteBuffer inventoryAsByteBuffer() { return __vector_as_bytebuffer(14, 1); }
+  public boolean mutateInventory(int j, int inventory) { int o = __offset(14); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)inventory); return true; } else { return false; } }
+  public byte color() { int o = __offset(16); return o != 0 ? bb.get(o + bb_pos) : 8; }
+  public boolean mutateColor(byte color) { int o = __offset(16); if (o != 0) { bb.put(o + bb_pos, color); return true; } else { return false; } }
+  public byte testType() { int o = __offset(18); return o != 0 ? bb.get(o + bb_pos) : 0; }
+  public boolean mutateTestType(byte test_type) { int o = __offset(18); if (o != 0) { bb.put(o + bb_pos, test_type); return true; } else { return false; } }
+  public Table test(Table obj) { int o = __offset(20); return o != 0 ? __union(obj, o) : null; }
+  public Test test4(int j) { return test4(new Test(), j); }
+  public Test test4(Test obj, int j) { int o = __offset(22); return o != 0 ? obj.__init(__vector(o) + j * 4, bb) : null; }
+  public int test4Length() { int o = __offset(22); return o != 0 ? __vector_len(o) : 0; }
+  public String testarrayofstring(int j) { int o = __offset(24); return o != 0 ? __string(__vector(o) + j * 4) : null; }
+  public int testarrayofstringLength() { int o = __offset(24); return o != 0 ? __vector_len(o) : 0; }
+  /**
+   * an example documentation comment: this will end up in the generated code
+   * multiline too
+   */
+  public Monster testarrayoftables(int j) { return testarrayoftables(new Monster(), j); }
+  public Monster testarrayoftables(Monster obj, int j) { int o = __offset(26); return o != 0 ? obj.__init(__indirect(__vector(o) + j * 4), bb) : null; }
+  public int testarrayoftablesLength() { int o = __offset(26); return o != 0 ? __vector_len(o) : 0; }
+  public Monster enemy() { return enemy(new Monster()); }
+  public Monster enemy(Monster obj) { int o = __offset(28); return o != 0 ? obj.__init(__indirect(o + bb_pos), bb) : null; }
+  public int testnestedflatbuffer(int j) { int o = __offset(30); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
+  public int testnestedflatbufferLength() { int o = __offset(30); return o != 0 ? __vector_len(o) : 0; }
+  public ByteBuffer testnestedflatbufferAsByteBuffer() { return __vector_as_bytebuffer(30, 1); }
+  public boolean mutateTestnestedflatbuffer(int j, int testnestedflatbuffer) { int o = __offset(30); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)testnestedflatbuffer); return true; } else { return false; } }
+  public Stat testempty() { return testempty(new Stat()); }
+  public Stat testempty(Stat obj) { int o = __offset(32); return o != 0 ? obj.__init(__indirect(o + bb_pos), bb) : null; }
+  public boolean testbool() { int o = __offset(34); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+  public boolean mutateTestbool(boolean testbool) { int o = __offset(34); if (o != 0) { bb.put(o + bb_pos, (byte)(testbool ? 1 : 0)); return true; } else { return false; } }
+  public int testhashs32Fnv1() { int o = __offset(36); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
+  public boolean mutateTesthashs32Fnv1(int testhashs32_fnv1) { int o = __offset(36); if (o != 0) { bb.putInt(o + bb_pos, testhashs32_fnv1); return true; } else { return false; } }
+  public long testhashu32Fnv1() { int o = __offset(38); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0; }
+  public boolean mutateTesthashu32Fnv1(long testhashu32_fnv1) { int o = __offset(38); if (o != 0) { bb.putInt(o + bb_pos, (int)testhashu32_fnv1); return true; } else { return false; } }
+  public long testhashs64Fnv1() { int o = __offset(40); return o != 0 ? bb.getLong(o + bb_pos) : 0; }
+  public boolean mutateTesthashs64Fnv1(long testhashs64_fnv1) { int o = __offset(40); if (o != 0) { bb.putLong(o + bb_pos, testhashs64_fnv1); return true; } else { return false; } }
+  public long testhashu64Fnv1() { int o = __offset(42); return o != 0 ? bb.getLong(o + bb_pos) : 0; }
+  public boolean mutateTesthashu64Fnv1(long testhashu64_fnv1) { int o = __offset(42); if (o != 0) { bb.putLong(o + bb_pos, testhashu64_fnv1); return true; } else { return false; } }
+  public int testhashs32Fnv1a() { int o = __offset(44); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
+  public boolean mutateTesthashs32Fnv1a(int testhashs32_fnv1a) { int o = __offset(44); if (o != 0) { bb.putInt(o + bb_pos, testhashs32_fnv1a); return true; } else { return false; } }
+  public long testhashu32Fnv1a() { int o = __offset(46); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0; }
+  public boolean mutateTesthashu32Fnv1a(long testhashu32_fnv1a) { int o = __offset(46); if (o != 0) { bb.putInt(o + bb_pos, (int)testhashu32_fnv1a); return true; } else { return false; } }
+  public long testhashs64Fnv1a() { int o = __offset(48); return o != 0 ? bb.getLong(o + bb_pos) : 0; }
+  public boolean mutateTesthashs64Fnv1a(long testhashs64_fnv1a) { int o = __offset(48); if (o != 0) { bb.putLong(o + bb_pos, testhashs64_fnv1a); return true; } else { return false; } }
+  public long testhashu64Fnv1a() { int o = __offset(50); return o != 0 ? bb.getLong(o + bb_pos) : 0; }
+  public boolean mutateTesthashu64Fnv1a(long testhashu64_fnv1a) { int o = __offset(50); if (o != 0) { bb.putLong(o + bb_pos, testhashu64_fnv1a); return true; } else { return false; } }
+  public boolean testarrayofbools(int j) { int o = __offset(52); return o != 0 ? 0!=bb.get(__vector(o) + j * 1) : false; }
+  public int testarrayofboolsLength() { int o = __offset(52); return o != 0 ? __vector_len(o) : 0; }
+  public ByteBuffer testarrayofboolsAsByteBuffer() { return __vector_as_bytebuffer(52, 1); }
+  public boolean mutateTestarrayofbools(int j, boolean testarrayofbools) { int o = __offset(52); if (o != 0) { bb.put(__vector(o) + j * 1, (byte)(testarrayofbools ? 1 : 0)); return true; } else { return false; } }
+
+  public static void startMonster(FlatBufferBuilder builder) { builder.startObject(25); }
+  public static void addPos(FlatBufferBuilder builder, int posOffset) { builder.addStruct(0, posOffset, 0); }
+  public static void addMana(FlatBufferBuilder builder, short mana) { builder.addShort(1, mana, 150); }
+  public static void addHp(FlatBufferBuilder builder, short hp) { builder.addShort(2, hp, 100); }
+  public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(3, nameOffset, 0); }
+  public static void addInventory(FlatBufferBuilder builder, int inventoryOffset) { builder.addOffset(5, inventoryOffset, 0); }
+  public static int createInventoryVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
+  public static void startInventoryVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
+  public static void addColor(FlatBufferBuilder builder, byte color) { builder.addByte(6, color, 8); }
+  public static void addTestType(FlatBufferBuilder builder, byte testType) { builder.addByte(7, testType, 0); }
+  public static void addTest(FlatBufferBuilder builder, int testOffset) { builder.addOffset(8, testOffset, 0); }
+  public static void addTest4(FlatBufferBuilder builder, int test4Offset) { builder.addOffset(9, test4Offset, 0); }
+  public static void startTest4Vector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 2); }
+  public static void addTestarrayofstring(FlatBufferBuilder builder, int testarrayofstringOffset) { builder.addOffset(10, testarrayofstringOffset, 0); }
+  public static int createTestarrayofstringVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startTestarrayofstringVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static void addTestarrayoftables(FlatBufferBuilder builder, int testarrayoftablesOffset) { builder.addOffset(11, testarrayoftablesOffset, 0); }
+  public static int createTestarrayoftablesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startTestarrayoftablesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static void addEnemy(FlatBufferBuilder builder, int enemyOffset) { builder.addOffset(12, enemyOffset, 0); }
+  public static void addTestnestedflatbuffer(FlatBufferBuilder builder, int testnestedflatbufferOffset) { builder.addOffset(13, testnestedflatbufferOffset, 0); }
+  public static int createTestnestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
+  public static void startTestnestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
+  public static void addTestempty(FlatBufferBuilder builder, int testemptyOffset) { builder.addOffset(14, testemptyOffset, 0); }
+  public static void addTestbool(FlatBufferBuilder builder, boolean testbool) { builder.addBoolean(15, testbool, false); }
+  public static void addTesthashs32Fnv1(FlatBufferBuilder builder, int testhashs32Fnv1) { builder.addInt(16, testhashs32Fnv1, 0); }
+  public static void addTesthashu32Fnv1(FlatBufferBuilder builder, long testhashu32Fnv1) { builder.addInt(17, (int)(testhashu32Fnv1 & 0xFFFFFFFFL), 0); }
+  public static void addTesthashs64Fnv1(FlatBufferBuilder builder, long testhashs64Fnv1) { builder.addLong(18, testhashs64Fnv1, 0); }
+  public static void addTesthashu64Fnv1(FlatBufferBuilder builder, long testhashu64Fnv1) { builder.addLong(19, testhashu64Fnv1, 0); }
+  public static void addTesthashs32Fnv1a(FlatBufferBuilder builder, int testhashs32Fnv1a) { builder.addInt(20, testhashs32Fnv1a, 0); }
+  public static void addTesthashu32Fnv1a(FlatBufferBuilder builder, long testhashu32Fnv1a) { builder.addInt(21, (int)(testhashu32Fnv1a & 0xFFFFFFFFL), 0); }
+  public static void addTesthashs64Fnv1a(FlatBufferBuilder builder, long testhashs64Fnv1a) { builder.addLong(22, testhashs64Fnv1a, 0); }
+  public static void addTesthashu64Fnv1a(FlatBufferBuilder builder, long testhashu64Fnv1a) { builder.addLong(23, testhashu64Fnv1a, 0); }
+  public static void addTestarrayofbools(FlatBufferBuilder builder, int testarrayofboolsOffset) { builder.addOffset(24, testarrayofboolsOffset, 0); }
+  public static int createTestarrayofboolsVector(FlatBufferBuilder builder, boolean[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addBoolean(data[i]); return builder.endVector(); }
+  public static void startTestarrayofboolsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
+  public static int endMonster(FlatBufferBuilder builder) {
+    int o = builder.endObject();
+    builder.required(o, 10);  // name
+    return o;
+  }
+  public static void finishMonsterBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset, "MONS"); }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Stat.java b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Stat.java
new file mode 100644
index 0000000..73f9562
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Stat.java
@@ -0,0 +1,43 @@
+// automatically generated, do not modify
+
+package MyGame.Example;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class Stat extends Table {
+  public static Stat getRootAsStat(ByteBuffer _bb) { return getRootAsStat(_bb, new Stat()); }
+  public static Stat getRootAsStat(ByteBuffer _bb, Stat obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public Stat __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public String id() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer idAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+  public long val() { int o = __offset(6); return o != 0 ? bb.getLong(o + bb_pos) : 0; }
+  public boolean mutateVal(long val) { int o = __offset(6); if (o != 0) { bb.putLong(o + bb_pos, val); return true; } else { return false; } }
+  public int count() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  public boolean mutateCount(int count) { int o = __offset(8); if (o != 0) { bb.putShort(o + bb_pos, (short)count); return true; } else { return false; } }
+
+  public static int createStat(FlatBufferBuilder builder,
+      int id,
+      long val,
+      int count) {
+    builder.startObject(3);
+    Stat.addVal(builder, val);
+    Stat.addId(builder, id);
+    Stat.addCount(builder, count);
+    return Stat.endStat(builder);
+  }
+
+  public static void startStat(FlatBufferBuilder builder) { builder.startObject(3); }
+  public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addOffset(0, idOffset, 0); }
+  public static void addVal(FlatBufferBuilder builder, long val) { builder.addLong(1, val, 0); }
+  public static void addCount(FlatBufferBuilder builder, int count) { builder.addShort(2, (short)(count & 0xFFFF), 0); }
+  public static int endStat(FlatBufferBuilder builder) {
+    int o = builder.endObject();
+    return o;
+  }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Test.java b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Test.java
new file mode 100644
index 0000000..ffd7394
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Test.java
@@ -0,0 +1,27 @@
+// automatically generated, do not modify
+
+package MyGame.Example;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class Test extends Struct {
+  public Test __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public short a() { return bb.getShort(bb_pos + 0); }
+  public void mutateA(short a) { bb.putShort(bb_pos + 0, a); }
+  public byte b() { return bb.get(bb_pos + 2); }
+  public void mutateB(byte b) { bb.put(bb_pos + 2, b); }
+
+  public static int createTest(FlatBufferBuilder builder, short a, byte b) {
+    builder.prep(2, 4);
+    builder.pad(1);
+    builder.putByte(b);
+    builder.putShort(a);
+    return builder.offset();
+  }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/TestSimpleTableWithEnum.java b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/TestSimpleTableWithEnum.java
new file mode 100644
index 0000000..3000cab
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/TestSimpleTableWithEnum.java
@@ -0,0 +1,33 @@
+// automatically generated, do not modify
+
+package MyGame.Example;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class TestSimpleTableWithEnum extends Table {
+  public static TestSimpleTableWithEnum getRootAsTestSimpleTableWithEnum(ByteBuffer _bb) { return getRootAsTestSimpleTableWithEnum(_bb, new TestSimpleTableWithEnum()); }
+  public static TestSimpleTableWithEnum getRootAsTestSimpleTableWithEnum(ByteBuffer _bb, TestSimpleTableWithEnum obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public TestSimpleTableWithEnum __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public byte color() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 2; }
+  public boolean mutateColor(byte color) { int o = __offset(4); if (o != 0) { bb.put(o + bb_pos, color); return true; } else { return false; } }
+
+  public static int createTestSimpleTableWithEnum(FlatBufferBuilder builder,
+      byte color) {
+    builder.startObject(1);
+    TestSimpleTableWithEnum.addColor(builder, color);
+    return TestSimpleTableWithEnum.endTestSimpleTableWithEnum(builder);
+  }
+
+  public static void startTestSimpleTableWithEnum(FlatBufferBuilder builder) { builder.startObject(1); }
+  public static void addColor(FlatBufferBuilder builder, byte color) { builder.addByte(0, color, 2); }
+  public static int endTestSimpleTableWithEnum(FlatBufferBuilder builder) {
+    int o = builder.endObject();
+    return o;
+  }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Vec3.java b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Vec3.java
new file mode 100644
index 0000000..86edb6d
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/MyGame/Example/Vec3.java
@@ -0,0 +1,44 @@
+// automatically generated, do not modify
+
+package MyGame.Example;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+public final class Vec3 extends Struct {
+  public Vec3 __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public float x() { return bb.getFloat(bb_pos + 0); }
+  public void mutateX(float x) { bb.putFloat(bb_pos + 0, x); }
+  public float y() { return bb.getFloat(bb_pos + 4); }
+  public void mutateY(float y) { bb.putFloat(bb_pos + 4, y); }
+  public float z() { return bb.getFloat(bb_pos + 8); }
+  public void mutateZ(float z) { bb.putFloat(bb_pos + 8, z); }
+  public double test1() { return bb.getDouble(bb_pos + 16); }
+  public void mutateTest1(double test1) { bb.putDouble(bb_pos + 16, test1); }
+  public byte test2() { return bb.get(bb_pos + 24); }
+  public void mutateTest2(byte test2) { bb.put(bb_pos + 24, test2); }
+  public Test test3() { return test3(new Test()); }
+  public Test test3(Test obj) { return obj.__init(bb_pos + 26, bb); }
+
+  public static int createVec3(FlatBufferBuilder builder, float x, float y, float z, double test1, byte test2, short test3_a, byte test3_b) {
+    builder.prep(16, 32);
+    builder.pad(2);
+    builder.prep(2, 4);
+    builder.pad(1);
+    builder.putByte(test3_b);
+    builder.putShort(test3_a);
+    builder.pad(1);
+    builder.putByte(test2);
+    builder.putDouble(test1);
+    builder.pad(4);
+    builder.putFloat(z);
+    builder.putFloat(y);
+    builder.putFloat(x);
+    return builder.offset();
+  }
+};
+
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/org/apache/kerby/kerberos/kerb/identity/backend/FlatbuffersBackendTest.java b/kerby-backend/flatbuffers-backend/src/test/java/org/apache/kerby/kerberos/kerb/identity/backend/FlatbuffersBackendTest.java
new file mode 100644
index 0000000..aa3b4eb
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/org/apache/kerby/kerberos/kerb/identity/backend/FlatbuffersBackendTest.java
@@ -0,0 +1,56 @@
+/**
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *  
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *  
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License. 
+ *  
+ */
+package org.apache.kerby.kerberos.kerb.identity.backend;
+
+import org.apache.kerby.config.Conf;
+import org.apache.kerby.config.Config;
+import org.apache.kerby.kerberos.kdc.identitybackend.FlatbuffersIdentityBackend;
+import org.apache.kerby.kerberos.kerb.KrbException;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+import java.io.File;
+
+/**
+ * Flatbuffers backend test
+ */
+public class FlatbuffersBackendTest extends BackendTestBase {
+    private static File fbsBackendFile;
+
+    @BeforeClass
+    public static void setup() throws KrbException {
+        File testDir = new File(System.getProperty("test.dir", "target"));
+        fbsBackendFile = new File(testDir, "fbs-identity-backend-file");
+        String jsonBackendFileString = fbsBackendFile.getAbsolutePath();
+
+        Config backendConfig = new Conf();
+        backendConfig.setString(FlatbuffersIdentityBackend.FBS_IDENTITY_BACKEND_DIR,
+                jsonBackendFileString);
+        backend = new FlatbuffersIdentityBackend(backendConfig);
+        backend.initialize();
+    }
+
+    @AfterClass
+    public static void cleanJsonBackendFile() {
+        if (fbsBackendFile.exists()) {
+            fbsBackendFile.delete();
+        }
+    }
+}
diff --git a/kerby-backend/flatbuffers-backend/src/test/java/org/apache/kerby/kerberos/kerb/identity/backend/FlatbuffersBackendTestUtil.java b/kerby-backend/flatbuffers-backend/src/test/java/org/apache/kerby/kerberos/kerb/identity/backend/FlatbuffersBackendTestUtil.java
new file mode 100644
index 0000000..8061ae5
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/java/org/apache/kerby/kerberos/kerb/identity/backend/FlatbuffersBackendTestUtil.java
@@ -0,0 +1,77 @@
+/**
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License. 
+ *
+ */
+package org.apache.kerby.kerberos.kerb.identity.backend;
+
+import MyGame.Example.*;
+import com.google.flatbuffers.FlatBufferBuilder;
+import org.apache.kerby.kerberos.kdc.identitybackend.FbsEncryptionKey;
+import org.apache.kerby.kerberos.kdc.identitybackend.FbsKerby;
+import org.apache.kerby.kerberos.kdc.identitybackend.FbsKrbIdentity;
+import org.apache.kerby.kerberos.kdc.identitybackend.FbsPrincipalName;
+import org.apache.kerby.kerberos.kerb.KrbException;
+import org.apache.kerby.kerberos.kerb.identity.KrbIdentity;
+import org.apache.kerby.kerberos.kerb.spec.base.EncryptionKey;
+import org.apache.kerby.kerberos.kerb.spec.base.PrincipalName;
+
+import java.io.DataOutputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.List;
+
+/**
+ * Flatbuffers test utilities
+ */
+public class FlatbuffersBackendTestUtil {
+
+    public static void main(String[] args) throws KrbException {
+        List<KrbIdentity> idendenties = BackendTestUtil.createManyIdentities(2);
+
+        FlatBufferBuilder fbb = new FlatBufferBuilder(1024);
+
+        int name = fbb.createString("KerbyBackend");
+
+        KrbIdentity krbId = idendenties.get(0);
+        int princNameOff = fbb.createString(krbId.getPrincipalName());
+        int nameType = krbId.getPrincipal().getNameType().getValue();
+        int princOff = FbsPrincipalName.createFbsPrincipalName(fbb, nameType, princNameOff);
+        EncryptionKey encKey = krbId.getKeys().entrySet().iterator().next().getValue();
+        int keyValueOff = FbsEncryptionKey.createKeyValueVector(fbb, encKey.getKeyData());
+        int encKeyOff = FbsEncryptionKey.createFbsEncryptionKey(fbb,
+                encKey.getKeyType().getValue(), keyValueOff);
+        int keysOff = FbsKrbIdentity.createKeysVector(fbb, new int[]{encKeyOff});
+        int identityOff = FbsKrbIdentity.createFbsKrbIdentity(fbb, princOff, 1, 1, false, keysOff);
+        int idsOff = FbsKerby.createIdentitiesVector(fbb, new int[]{identityOff});
+
+        FbsKerby.startFbsKerby(fbb);
+        FbsKerby.addName(fbb, name);
+        FbsKerby.addIdentities(fbb, idsOff);
+        int kerbyOff = FbsKerby.endFbsKerby(fbb);
+        FbsKerby.finishFbsKerbyBuffer(fbb, kerbyOff);
+
+        ByteBuffer dataBuffer = fbb.dataBuffer().duplicate();
+
+        FbsKerby fbsKerby2 = FbsKerby.getRootAsFbsKerby(dataBuffer);
+        String kerbyName = fbsKerby2.name();
+        FbsKrbIdentity krbId2 = fbsKerby2.identities(0);
+        String princName2 = krbId2.principal().nameString();
+        return;
+    }
+}
diff --git a/kerby-backend/flatbuffers-backend/src/test/monsterdata_test.mon b/kerby-backend/flatbuffers-backend/src/test/monsterdata_test.mon
new file mode 100644
index 0000000..0505aee
--- /dev/null
+++ b/kerby-backend/flatbuffers-backend/src/test/monsterdata_test.mon
Binary files differ
diff --git a/kerby-backend/pom.xml b/kerby-backend/pom.xml
index 1305721..d49f40b 100644
--- a/kerby-backend/pom.xml
+++ b/kerby-backend/pom.xml
@@ -30,6 +30,7 @@
     <module>mavibot-backend</module>
     <module>json-backend</module>
     <module>zookeeper-backend</module>
+    <module>flatbuffers-backend</module>
   </modules>
 
   <dependencies>
diff --git a/monsterdata_java_wire.mon b/monsterdata_java_wire.mon
new file mode 100644
index 0000000..24602bc
--- /dev/null
+++ b/monsterdata_java_wire.mon
Binary files differ