diff --git a/src/main/frontend/package-lock.json b/src/main/frontend/package-lock.json
index fa834d75..2ea75d7e 100644
--- a/src/main/frontend/package-lock.json
+++ b/src/main/frontend/package-lock.json
@@ -951,9 +951,9 @@
       }
     },
     "@mdi/js": {
-      "version": "4.4.95",
-      "resolved": "https://registry.npmjs.org/@mdi/js/-/js-4.4.95.tgz",
-      "integrity": "sha512-wCrur/ICoHP7/NcNboBCdqR64gQnoUKxSRla4uOsGC61jMUnUeDMNfU7PrA/I0IzvotWc0ws2cCNVL7JsOPh2Q==",
+      "version": "4.5.95",
+      "resolved": "https://registry.npmjs.org/@mdi/js/-/js-4.5.95.tgz",
+      "integrity": "sha512-zQ6LqK/B61/ASwoR26AauCLfNc6u/SyTwsnWF0WLcSIh+oe+A7rQbioYT3eSsQch1gC+1Ejk8YDfD7gDk0FUXg==",
       "dev": true
     },
     "@mrmlnc/readdir-enhanced": {
diff --git a/src/main/frontend/package.json b/src/main/frontend/package.json
index f5e59c0b..4d6b573f 100644
--- a/src/main/frontend/package.json
+++ b/src/main/frontend/package.json
@@ -23,7 +23,7 @@
   "devDependencies": {
     "@babel/plugin-proposal-nullish-coalescing-operator": "^7.4.4",
     "@babel/plugin-proposal-optional-chaining": "^7.6.0",
-    "@mdi/js": "^4.4.95",
+    "@mdi/js": "^4.5.95",
     "@vue/cli-plugin-babel": "^3.4.0",
     "@vue/cli-plugin-eslint": "^3.4.0",
     "@vue/cli-service": "^3.8.0",
diff --git a/src/main/frontend/src/api/SchemataRepository.js b/src/main/frontend/src/api/SchemataRepository.js
index 57c9c0d4..943d487f 100644
--- a/src/main/frontend/src/api/SchemataRepository.js
+++ b/src/main/frontend/src/api/SchemataRepository.js
@@ -3,13 +3,20 @@ import Repository from '@/api/Repository'
 
 const resources = {
     organizations: () => '/organizations',
-    units: (o) => `/organizations/${o}/units`,
-    contexts: (o, u) => `/organizations/${o}/units/${u}/contexts`,
+    organization: (o) => `${resources.organizations()}/${o}`,
+    units: (o) => `${resources.organization(o)}/units`,
+    unit: (o, u) => `${resources.units(o)}/${u}`,
+    contexts: (o, u) => `${resources.unit(o, u)}/contexts`,
+    context: (o, u, c) => `${resources.contexts(o, u)}/${c}`,
     categories: () => '/schema/categories',
     scopes: () => '/schema/scopes',
-    schemata: (o, u, c) => `/organizations/${o}/units/${u}/contexts/${c}/schemas`,
-    versions: (o, u, c, s) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions`,
-    schemaSpecification: (o, u, c, s, v) => `/organizations/${o}/units/${u}/contexts/${c}/schemas/${s}/versions/${v}/specification`
+    schemata: (o, u, c) => `${resources.context(o, u, c)}/schemas`,
+    schema: (o, u, c, s) => `${resources.schemata(o, u, c)}/${s}`,
+    versions: (o, u, c, s) => `${resources.schema(o, u, c, s)}/versions`,
+    version: (o, u, c, s, v) => `${resources.versions(o, u, c, s)}/${v}`,
+    versionStatus: (o, u, c, s, v) => `${resources.version(o, u, c, s, v)}/status`,
+    schemaSpecification: (o, u, c, s, v) => `${resources.version(o, u, c, s, v)}/specification`,
+    sources: (o, u, c, s, v, lang) => `/code/${o}:${u}:${c}:${s}:${v}/${lang}`,
 }
 
 function ensure(response, status) {
@@ -33,18 +40,34 @@ export default {
             .then(ensureOk)
             .then(response => response.data)
     },
+    getOrganization(organization) {
+        return Repository.get(resources.organization(organization))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 
     getUnits(organization) {
         return Repository.get(resources.units(organization))
             .then(ensureOk)
             .then(response => response.data)
     },
+    getUnit(organization, unit) {
+        return Repository.get(resources.unit(organization, unit))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 
     getContexts(organization, unit) {
         return Repository.get(resources.contexts(organization, unit))
             .then(ensureOk)
             .then(response => response.data)
     },
+    getContext(organization, unit, context) {
+        return Repository.get(resources.context(organization, unit, context))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
+
     getCategories() {
         return Repository.get(resources.categories())
             .then(ensureOk)
@@ -60,12 +83,22 @@ export default {
             .then(ensureOk)
             .then(response => response.data)
     },
+    getSchema(organization, unit, context, schema) {
+        return Repository.get(resources.schema(organization, unit, context, schema))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 
     getVersions(organization, unit, context, schema) {
         return Repository.get(resources.versions(organization, unit, context, schema))
             .then(ensureOk)
             .then(response => response.data)
     },
+    getVersion(organization, unit, context, schema, version) {
+        return Repository.get(resources.version(organization, unit, context, schema, version))
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 
     createOrganization(name, description) {
         return Repository.post(resources.organizations(),
@@ -115,12 +148,11 @@ export default {
     },
     createSchemaVersion(
         organization, unit, context, schema,
-        specification, description, status, previousVersion, currentVersion) {
+        specification, description, previousVersion, currentVersion) {
         return Repository.post(resources.versions(organization, unit, context, schema),
             {
                 schemaVersionId: '',
                 specification: specification,
-                status: status,
                 previousVersion: previousVersion,
                 currentVersion: currentVersion,
                 description: description
@@ -145,4 +177,48 @@ export default {
             .then(ensureOk)
             .then(response => response.data)
     },
+    setSchemaVersionStatus(
+        organization, unit, context, schema, version, status) {
+
+        let config = {
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            responseType: 'text'
+        };
+        return Repository.patch(
+            resources.versionStatus(organization, unit, context, schema, version),
+            status,
+            config
+        )
+            .then(ensureOk)
+            .then(response => response.data)
+    },
+    loadSources(
+        organization, unit, context, schema, version, language) {
+        let config = {
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            responseType: 'text'
+        };
+        return Promise.all([
+            this.getOrganization(organization),
+            this.getUnit(organization, unit),
+            this.getContext(organization, unit, context),
+            this.getSchema(organization, unit, context, schema),
+            this.getVersion(organization, unit, context, schema, version),
+        ]).then(([org, unit, context, schema, version]) => {
+            return Repository.get(
+                resources.sources(
+                    org.name,
+                    unit.name,
+                    context.namespace,
+                    schema.name,
+                    version.currentVersion,
+                    language), config)
+        })
+            .then(ensureOk)
+            .then(response => response.data)
+    },
 }
\ No newline at end of file
diff --git a/src/main/frontend/src/components/Properties.vue b/src/main/frontend/src/components/Properties.vue
index b6c2db40..069de937 100644
--- a/src/main/frontend/src/components/Properties.vue
+++ b/src/main/frontend/src/components/Properties.vue
@@ -1,14 +1,17 @@
 <template>
     <v-card height="45vh" id="schemata-properties">
-        <v-card-text>
-            <v-alert v-if="status && status !== 'Published'" :value="true" type="warning" dense outlined>
-                Status <b>{{status}}</b>. Do not use in production.
-            </v-alert>
-            <v-tabs>
-                <v-tab>Specification</v-tab>
-                <v-tab>Description</v-tab>
 
-                <v-tab-item>
+        <v-tabs>
+            <v-tab>Specification</v-tab>
+            <v-tab>Description</v-tab>
+            <v-spacer></v-spacer>
+            <v-chip label color="warning" v-if="status && status !== 'Published'" class="mt-3 mr-3">
+                Status&nbsp;<b>{{status}}</b>. Do not use in production.
+            </v-chip>
+
+
+            <v-tab-item>
+                <v-card-text>
                     <editor
                             id="specification-editor"
                             v-model="currentSpecification"
@@ -17,37 +20,84 @@
                             height="200"
                             :options="editorOptions"
                     ></editor>
-                    <br>
+                </v-card-text>
+                <v-card-actions>
+                    <v-btn outlined color="primary" @click="publish"
+                           :disabled="status !== 'Draft'">
+                        <v-icon>{{icons.publish}}</v-icon>
+                        Publish
+                    </v-btn>
+                    <v-btn outlined color="warning" @click="deprecate"
+                           :disabled="status !== 'Published' && status !== 'Draft'">
+                        <v-icon>{{icons.deprecate}}</v-icon>
+                        Deprecate
+                    </v-btn>
+                    <v-btn outlined color="error" @click="remove"
+                           :disabled="status !== 'Deprecated' && status !== 'Draft'">
+                        <v-icon>{{icons.delete}}</v-icon>
+                        Remove
+                    </v-btn>
+                    <v-spacer></v-spacer>
+                    <v-btn outlined color="info"
+                           :disabled="!version"
+                           @click="loadSources">
+                        <v-icon>{{icons.source}}</v-icon>
+                        Source
+                    </v-btn>
                     <v-btn color="info"
                            :disabled="status !== 'Draft'"
                            @click="saveSpecification">Save
                     </v-btn>
-                </v-tab-item>
+                </v-card-actions>
+                <v-dialog v-model="sourceDialog">
+                    <v-card>
+                        <editor
+                                id="source-editor"
+                                v-model="sources.java"
+                                theme="vs-dark"
+                                language="java"
+                                height="400"
+                                :options="{ readOnly: true, automaticLayout: true }"
+                        ></editor>
+                    </v-card>
+                </v-dialog>
+            </v-tab-item>
 
-                <v-tab-item>
+            <v-tab-item>
+                <v-card-text>
                     <div v-html="compiledDescription()"></div>
-                </v-tab-item>
-            </v-tabs>
-        </v-card-text>
-    </v-card>
+                </v-card-text>
+            </v-tab-item>
+        </v-tabs>
 
+    </v-card>
 
 </template>
 
 <script>
     import {mapFields} from 'vuex-map-fields';
+    import {mdiDelete, mdiLabel, mdiLabelOff, mdiSourcePull} from '@mdi/js'
     import marked from 'marked'
-    import editor from 'monaco-editor-vue';
     import Repository from '@/api/SchemataRepository'
+    import editor from 'monaco-editor-vue';
 
     export default {
         components: {editor},
         data: function () {
             return {
                 currentSpecification: undefined,
+                icons: {
+                    publish: mdiLabel,
+                    delete: mdiDelete,
+                    deprecate: mdiLabelOff,
+                    source: mdiSourcePull
+                },
+                sourceDialog: false,
+                sources: {
+                    java: undefined,
+                }
             }
         },
-
         computed: {
             ...mapFields([
                 'schema',
@@ -80,6 +130,41 @@
             compiledDescription: function () {
                 return marked(this.description)
             },
+
+            publish() {
+                this._setStatus('Published')
+            },
+            deprecate() {
+                this._setStatus('Deprecated')
+            },
+            remove() {
+                this._setStatus('Removed')
+            },
+
+            _setStatus(status) {
+                let vm = this
+                Repository.setSchemaVersionStatus(
+                    this.version.organizationId,
+                    this.version.unitId,
+                    this.version.contextId,
+                    this.version.schemaId,
+                    this.version.schemaVersionId,
+                    status)
+                    .then(response => vm.$store.dispatch('selectSchemaVersion', response))
+                    .then(() => vm.$store.dispatch('loadVersions'))
+                    .then(() => {
+                            vm.$store.commit('raiseNotification', {
+                                message: `Status for ${vm.schema.name} updated.`,
+                                type: 'success'
+                            })
+                        }
+                    )
+                    .catch(function (err) {
+                        let response = err.response ? err.response.data + ' - ' : ''
+                        vm.$store.commit('raiseError', {message: response + err})
+                    })
+            },
+
             saveSpecification: function () {
                 let vm = this
                 Repository.saveSchemaVersionSpecification(
@@ -90,6 +175,8 @@
                     this.version.schemaVersionId,
                     this.currentSpecification
                 )
+                    .then(response => vm.$store.dispatch('selectSchemaVersion', response))
+                    .then(() => vm.$store.dispatch('loadVersions'))
                     .then(() => {
                             vm.$store.commit('raiseNotification', {
                                 message: `Specification for ${vm.schema.name} v${vm.version.currentVersion} updated.`,
@@ -101,10 +188,30 @@
                         let response = err.response ? err.response.data + ' - ' : ''
                         vm.$store.commit('raiseError', {message: response + err})
                     })
+            },
+            loadSources() {
+                let vm = this
+                Repository.loadSources(
+                    this.version.organizationId,
+                    this.version.unitId,
+                    this.version.contextId,
+                    this.version.schemaId,
+                    this.version.schemaVersionId,
+                    "java"
+                )
+                    .then(response => {
+                        vm.sources.java = response
+                        vm.sourceDialog = true
+                    })
+                    .catch(function (err) {
+                        let response = err.response ? err.response.data + ' - ' : ''
+                        vm.$store.commit('raiseError', {message: response + err})
+                    })
             }
         }
     }
 </script>
 
 <style>
+
 </style>
diff --git a/src/main/frontend/src/components/SchemaVersion.vue b/src/main/frontend/src/components/SchemaVersion.vue
index e568002f..3834a2cb 100644
--- a/src/main/frontend/src/components/SchemaVersion.vue
+++ b/src/main/frontend/src/components/SchemaVersion.vue
@@ -66,7 +66,7 @@
                     </v-col>
 
 
-                    <v-col class="d-flex" cols="4">
+                    <v-col class="d-flex" cols="6">
                         <v-text-field
                                 v-model="previousVersion"
                                 :rules="[rules.notEmpty,rules.versionNumber]"
@@ -75,7 +75,7 @@
                         ></v-text-field>
                     </v-col>
 
-                    <v-col class="d-flex" cols="4">
+                    <v-col class="d-flex" cols="6">
                         <v-text-field
                                 v-model="currentVersion"
                                 :rules="[rules.notEmpty,rules.versionNumber]"
@@ -84,15 +84,6 @@
                         ></v-text-field>
                     </v-col>
 
-                    <v-col class="d-flex" cols="4">
-                        <v-autocomplete
-                                :items="statuses"
-                                :rules="[rules.notEmpty]"
-                                label="Status"
-                                v-model="status"
-                        ></v-autocomplete>
-                    </v-col>
-
                     <v-col cols="12">
                         <label class="v-label theme--light"
                                :class="{'primary--text':descriptionEditorActive}">Description</label>
@@ -149,10 +140,8 @@
                 schemaVersionId: '',
                 description: '',
                 specification: '',
-                status: 'Draft',
                 previousVersion: '',
                 currentVersion: '',
-                statuses: ['Draft', 'Published', 'Deprecated', 'Removed'],
 
                 descriptionEditorActive: false,
                 specificationEditorActive: false,
@@ -173,7 +162,6 @@
                     this.schema.schemaId,
                     this.specification,
                     this.description,
-                    this.status,
                     this.previousVersion,
                     this.currentVersion)
                     .then((created) => {
@@ -189,6 +177,7 @@
                                 message: `Schema v${vm.currentVersion} created.`,
                                 type: 'success'
                             })
+                            vm.$store.dispatch('loadVersions')
                         }
                     )
                     .catch(function (err) {
diff --git a/src/main/frontend/src/components/Schemata.vue b/src/main/frontend/src/components/Schemata.vue
index fec6cbae..dc2bb279 100644
--- a/src/main/frontend/src/components/Schemata.vue
+++ b/src/main/frontend/src/components/Schemata.vue
@@ -80,7 +80,7 @@
                     return [this.$store.schema]
                 },
                 set(value) {
-                    this.$store.commit('selectSchema', value[0])
+                    this.$store.dispatch('selectSchema', value[0])
                 }
             },
 
@@ -100,6 +100,7 @@
                             vm.items.push(organization)
                         }
                     })
+                    .catch((err) => vm.$store.commit('raiseError', {message: err}))
             },
 
             async loadChildren(item) {
diff --git a/src/main/frontend/src/components/Versions.vue b/src/main/frontend/src/components/Versions.vue
index 2f70c54a..10983081 100644
--- a/src/main/frontend/src/components/Versions.vue
+++ b/src/main/frontend/src/components/Versions.vue
@@ -3,7 +3,7 @@
     <v-card height="45vh" id="schemata-versions">
         <v-list dense>
             <v-list-item-group v-model="selected" color="primary">
-                <v-list-item v-for="v in versions" :key="v.id" ripple>
+                <v-list-item v-for="v in schemaVersions" :key="v.id" ripple>
                     <v-list-item-action>
                         <v-tooltip right>
                             <template v-slot:activator="{ on }">
@@ -26,8 +26,7 @@
 </template>
 
 <script>
-    import {mdiDelete, mdiPencil, mdiTag} from '@mdi/js'
-    import Repository from '@/api/SchemataRepository'
+    import {mdiDelete, mdiLabel, mdiLabelOff, mdiPencil} from '@mdi/js'
     import {mapFields} from 'vuex-map-fields';
 
     export default {
@@ -44,45 +43,31 @@
                 if (value === undefined) {
                     this.version = undefined
                 } else {
-                    this.version = this.versions[value]
+                    this.version = this.schemaVersions[value]
                 }
             }
         },
         computed: {
             ...mapFields([
                 'schema',
-                'version'
+                'schemaVersions',
+                'version',
             ]),
         },
-        asyncComputed: {
-            async versions() {
-                if (!(this.schema)) {
-                    return
-                }
-
-                let vm = this
-                return await Repository.getVersions(
-                    this.schema.organizationId,
-                    this.schema.unitId,
-                    this.schema.contextId,
-                    this.schema.schemaId)
-                    .catch(function (err) {
-                        vm.$emit('vs-error', {status: 0, message: err})
-                    });
-            }
-        },
         methods: {
             icon(version) {
                 if (!version) return '';
                 switch (version.status) {
                     case 'Published':
-                        return mdiTag
+                        return mdiLabel
                     case 'Draft':
                         return mdiPencil
+                    case 'Deprecated':
+                        return mdiLabelOff
                     case 'Removed':
                         return mdiDelete
                     default:
-                        return 'insert_drive_file'
+                        return ''
                 }
             }
         }
diff --git a/src/main/frontend/src/store.js b/src/main/frontend/src/store.js
index 567667d6..d636d850 100644
--- a/src/main/frontend/src/store.js
+++ b/src/main/frontend/src/store.js
@@ -1,58 +1,85 @@
 import Vue from 'vue'
 import Vuex from 'vuex'
-import { getField, updateField } from 'vuex-map-fields';
+import {getField, updateField} from 'vuex-map-fields';
+import Repository from "@/api/SchemataRepository";
 
 Vue.use(Vuex)
 
 export default new Vuex.Store({
-  strict: true,
-  state: {
-    error: undefined,
-    notification: undefined,
-    schemaVersion: undefined,
-    selected: undefined,
-    organization: undefined,
-    unit: undefined,
-    context: undefined,
-    category: undefined,
-    schema: undefined,
-    version: undefined
-  },
-  mutations: {
-    updateField,
-    raiseError (state, error) {
-      state.error = error
+    strict: true,
+    state: {
+        error: undefined,
+        notification: undefined,
+        schemaVersion: undefined,
+        selected: undefined,
+        organization: undefined,
+        unit: undefined,
+        context: undefined,
+        category: undefined,
+        schema: undefined,
+        schemaVersions: undefined,
+        version: undefined
     },
+    mutations: {
+        updateField,
+        raiseError(state, error) {
+            state.error = error
+        },
 
-    dismissError (state) {
-      state.error = undefined
-    },
+        dismissError(state) {
+            state.error = undefined
+        },
 
-    raiseNotification (state, notification) {
-      notification.type = notification.type || 'info'
-      state.notification = notification
-    },
+        raiseNotification(state, notification) {
+            notification.type = notification.type || 'info'
+            state.notification = notification
+        },
 
-    dismissNotification (state) {
-      state.notification = undefined
-    },
+        dismissNotification(state) {
+            state.notification = undefined
+        },
+
+        selectOrganization(state, selected) {
+            state.organization = selected
+        },
+        updateSchema(state, selected) {
+            state.schema = selected
+        },
+        updateSchemaVersion(state, selected) {
+            state.version = selected
+        },
+        updateSchemaVersions(state, versions) {
+            state.schemaVersions = versions
+        }
 
-    selectSchema (state, selected) {
-      state.schema = selected
-    },
-    selectOrganization (state, selected) {
-      state.organization = selected
     },
+    actions: {
+        selectSchema(context, selected) {
+            this.commit('updateSchema', selected)
+            this.dispatch('loadVersions')
+        },
+        selectSchemaVersion(context, selected) {
+            context.commit('updateSchemaVersion', selected)
+        },
+        loadVersions(context) {
+            if (!(context.state.schema)) {
+                return
+            }
 
-  },
-  actions: {
-
-  },
-  getters: {
-    getField,
-    organizationId: state => state.selected?.organizationId ?? undefined,
-    unitId: state => state.selected?.unitId ?? undefined,
-    contextId: state => state.selected?.contextId ?? undefined,
-    schemaId: state => state.selected?.schemaId ?? undefined,
-  }
+            Repository.getVersions(
+                context.state.schema.organizationId,
+                context.state.schema.unitId,
+                context.state.schema.contextId,
+                context.state.schema.schemaId)
+                .then(response => context.commit('updateSchemaVersions', response))
+                .catch(err => context.commit('raiseError', {status: 0, message: err}));
+        }
+    },
+    getters: {
+        getField,
+        organizationId: state => state.selected?.organizationId ?? undefined,
+        unitId: state => state.selected?.unitId ?? undefined,
+        contextId: state => state.selected?.contextId ?? undefined,
+        schemaId: state => state.selected?.schemaId ?? undefined,
+    }
 })
diff --git a/src/main/frontend/vue.config.js b/src/main/frontend/vue.config.js
index d4db71be..3fa66b54 100644
--- a/src/main/frontend/vue.config.js
+++ b/src/main/frontend/vue.config.js
@@ -12,13 +12,16 @@ module.exports = {
             },
             '/categories': {
                 target: 'http://localhost:9019/'
+            },
+            '/code': {
+                target: 'http://localhost:9019/'
             }
         },
     },
     chainWebpack: config => {
         config.plugin('monaco-editor').use(MonacoWebpackPlugin, [
             {
-                languages: ['javascript', 'markdown']
+                languages: ['javascript', 'markdown','java']
             }
         ])
     }
diff --git a/src/main/java/io/vlingo/schemata/infra/persistence/HSQLDBSchemataObjectStore.java b/src/main/java/io/vlingo/schemata/infra/persistence/HSQLDBSchemataObjectStore.java
index a79718cc..746a7d84 100644
--- a/src/main/java/io/vlingo/schemata/infra/persistence/HSQLDBSchemataObjectStore.java
+++ b/src/main/java/io/vlingo/schemata/infra/persistence/HSQLDBSchemataObjectStore.java
@@ -38,7 +38,7 @@ protected void createUnitStateTable() {
               "description VARCHAR(8000) " +
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS UNIT_PARENT_INDEX ON TBL_UNITS (organizationId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS UNIT_PARENT_INDEX ON TBL_UNITS (organizationId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS UNIT_ALL_INDEX ON TBL_UNITS (organizationId, unitId)");
       jdbi.handle().execute("ALTER TABLE TBL_UNITS ADD CONSTRAINT IF NOT EXISTS UNIT_ALL_UNIQUE UNIQUE (organizationId, name)");
   }
@@ -56,7 +56,7 @@ protected void createContextStateTable() {
               "description VARCHAR(8000) " +
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS CONTEXT_PARENT_INDEX ON TBL_CONTEXTS (organizationId, unitId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS CONTEXT_PARENT_INDEX ON TBL_CONTEXTS (organizationId, unitId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS CONTEXT_ALL_INDEX ON TBL_CONTEXTS (organizationId, unitId, contextId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_CONTEXTS ADD CONSTRAINT IF NOT EXISTS CONTEXT_ALL_UNIQUE UNIQUE (organizationId, unitId, namespace)");
@@ -78,7 +78,7 @@ protected void createSchemaStateTable() {
               "description VARCHAR(8000) " +
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMA_PARENT_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS SCHEMA_PARENT_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMA_ALL_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId, schemaId)");
       jdbi.handle().execute("ALTER TABLE TBL_SCHEMAS ADD CONSTRAINT IF NOT EXISTS SCHEMA_ALL_UNIQUE UNIQUE (organizationId, unitId, contextId, category, name)");
   }
@@ -117,7 +117,7 @@ protected void createSchemaVersionStateTable() {
 //              "UNIQUE (schemaId, currentVersion) " +
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMAVERSION_PARENT_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS SCHEMAVERSION_PARENT_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMAVERSION_ALL_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId, schemaVersionId)");
       jdbi.handle().execute("ALTER TABLE TBL_SCHEMAVERSIONS ADD CONSTRAINT IF NOT EXISTS SCHEMAVERSIION_ALL_UNIQUE UNIQUE (organizationId, unitId, contextId, schemaId, currentVersion)");
   }
diff --git a/src/main/java/io/vlingo/schemata/infra/persistence/PostgresSchemataObjectStore.java b/src/main/java/io/vlingo/schemata/infra/persistence/PostgresSchemataObjectStore.java
index 6a83d623..948729ba 100644
--- a/src/main/java/io/vlingo/schemata/infra/persistence/PostgresSchemataObjectStore.java
+++ b/src/main/java/io/vlingo/schemata/infra/persistence/PostgresSchemataObjectStore.java
@@ -46,7 +46,7 @@ protected void createUnitStateTable() {
 
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS UNIT_PARENT_INDEX ON TBL_UNITS (organizationId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS UNIT_PARENT_INDEX ON TBL_UNITS (organizationId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS UNIT_ALL_INDEX ON TBL_UNITS (organizationId, unitId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_UNITS DROP CONSTRAINT IF EXISTS UNIT_ALL_UNIQUE");
@@ -67,7 +67,7 @@ protected void createContextStateTable() {
 
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS CONTEXT_PARENT_INDEX ON TBL_CONTEXTS (organizationId, unitId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS CONTEXT_PARENT_INDEX ON TBL_CONTEXTS (organizationId, unitId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS CONTEXT_ALL_INDEX ON TBL_CONTEXTS (organizationId, unitId, contextId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_CONTEXTS DROP CONSTRAINT IF EXISTS CONTEXT_ALL_UNIQUE");
@@ -91,7 +91,7 @@ protected void createSchemaStateTable() {
 
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMA_PARENT_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS SCHEMA_PARENT_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMA_ALL_INDEX ON TBL_SCHEMAS (organizationId, unitId, contextId, schemaId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_SCHEMAS DROP CONSTRAINT IF EXISTS SCHEMA_ALL_UNIQUE");
@@ -132,7 +132,7 @@ protected void createSchemaVersionStateTable() {
 
               ")");
 
-      jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMAVERSION_PARENT_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId)");
+      jdbi.handle().execute("CREATE INDEX IF NOT EXISTS SCHEMAVERSION_PARENT_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId)");
       jdbi.handle().execute("CREATE UNIQUE INDEX IF NOT EXISTS SCHEMAVERSION_ALL_INDEX ON TBL_SCHEMAVERSIONS (organizationId, unitId, contextId, schemaId, schemaVersionId)");
 
       jdbi.handle().execute("ALTER TABLE TBL_SCHEMAVERSIONS DROP CONSTRAINT IF EXISTS SCHEMAVERSIION_ALL_UNIQUE");
diff --git a/src/main/java/io/vlingo/schemata/resource/SchemaVersionResource.java b/src/main/java/io/vlingo/schemata/resource/SchemaVersionResource.java
index 60bf32b4..81d7a4d4 100644
--- a/src/main/java/io/vlingo/schemata/resource/SchemaVersionResource.java
+++ b/src/main/java/io/vlingo/schemata/resource/SchemaVersionResource.java
@@ -7,22 +7,6 @@
 
 package io.vlingo.schemata.resource;
 
-import static io.vlingo.common.serialization.JsonSerialization.serialized;
-import static io.vlingo.http.Response.Status.BadRequest;
-import static io.vlingo.http.Response.Status.Conflict;
-import static io.vlingo.http.Response.Status.Created;
-import static io.vlingo.http.Response.Status.Ok;
-import static io.vlingo.http.ResponseHeader.ContentType;
-import static io.vlingo.http.ResponseHeader.Location;
-import static io.vlingo.http.ResponseHeader.of;
-import static io.vlingo.http.resource.ResourceBuilder.get;
-import static io.vlingo.http.resource.ResourceBuilder.patch;
-import static io.vlingo.http.resource.ResourceBuilder.post;
-import static io.vlingo.http.resource.ResourceBuilder.resource;
-import static io.vlingo.schemata.Schemata.NoId;
-import static io.vlingo.schemata.Schemata.SchemaVersionsPath;
-import static io.vlingo.schemata.Schemata.StageName;
-
 import io.vlingo.actors.Stage;
 import io.vlingo.actors.World;
 import io.vlingo.common.Completes;
@@ -40,142 +24,155 @@
 import io.vlingo.schemata.query.Queries;
 import io.vlingo.schemata.resource.data.SchemaVersionData;
 
+import static io.vlingo.common.serialization.JsonSerialization.serialized;
+import static io.vlingo.http.Response.Status.*;
+import static io.vlingo.http.ResponseHeader.*;
+import static io.vlingo.http.resource.ResourceBuilder.*;
+import static io.vlingo.schemata.Schemata.*;
+
 public class SchemaVersionResource extends ResourceHandler {
-  private final SchemaVersionCommands commands;
-  private final Stage stage;
-
-  public SchemaVersionResource(final World world) {
-    this.stage = world.stageNamed(StageName);
-    this.commands = new SchemaVersionCommands(this.stage, 10);
-  }
-
-  public Completes<Response> defineWith(
-          final String organizationId,
-          final String unitId,
-          final String contextId,
-          final String schemaId,
-          final SchemaVersionData data) {
-
-    if (!data.hasSpecification()) {
-      return Completes.withSuccess(Response.of(BadRequest, "Missing specification"));
+    private final SchemaVersionCommands commands;
+    private final Stage stage;
+
+    public SchemaVersionResource(final World world) {
+        this.stage = world.stageNamed(StageName);
+        this.commands = new SchemaVersionCommands(this.stage, 10);
+    }
+
+    public Completes<Response> defineWith(
+            final String organizationId,
+            final String unitId,
+            final String contextId,
+            final String schemaId,
+            final SchemaVersionData data) {
+
+        if (!data.hasSpecification()) {
+            return Completes.withSuccess(Response.of(BadRequest, "Missing specification"));
+        }
+        if (!data.validVersions()) {
+            return Completes.withSuccess(Response.of(BadRequest, "Conflicting versions"));
+        }
+
+        return SchemaVersion.with(stage, SchemaId.existing(organizationId, unitId, contextId, schemaId), Specification.of(data.specification), data.description, Version.of(data.previousVersion), Version.of(data.currentVersion))
+                .andThenTo(3000, state -> {
+                    final String location = schemaVersionLocation(state.schemaVersionId);
+                    final Headers<ResponseHeader> headers = Headers.of(
+                            of(Location, location),
+                            of(ContentType, "application/json; charset=UTF-8")
+                    );
+                    final String serialized = serialized(SchemaVersionData.from(state));
+
+                    return Completes.withSuccess(Response.of(Created, headers, serialized));
+                })
+                .otherwise(response -> Response.of(Conflict, serialized(SchemaVersionData.from(organizationId, unitId, contextId, schemaId, NoId, data.specification, data.description, "Draft", data.previousVersion, data.currentVersion))));
+    }
+
+    public Completes<Response> describeAs(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String description) {
+        return commands
+                .describeAs(SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId), description).answer()
+                .andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
+    }
+
+    public Completes<Response> specifyWith(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String specification) {
+        if (!SchemaVersionData.hasSpecification(specification)) {
+            return Completes.withSuccess(Response.of(BadRequest, "Missing specification"));
+        }
+
+        return commands
+                .specifyWith(SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId), Specification.of(specification)).answer()
+                .andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
     }
-    if (!data.validVersions()) {
-      return Completes.withSuccess(Response.of(BadRequest, "Conflicting versions"));
+
+    public Completes<Response> statusOf(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String status) {
+        final SchemaVersionId id = SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId);
+        final Completes<SchemaVersionState> answer;
+
+        switch (status.toLowerCase()) {
+            case "published":
+                answer = commands.publish(id).answer();
+                break;
+            case "deprecated":
+                answer = commands.deprecate(id).answer();
+                break;
+            case "removed":
+                answer = commands.remove(id).answer();
+                break;
+            default:
+                return Completes.withSuccess(Response.of(Conflict, serialized(SchemaVersionData.from(organizationId, unitId, contextId, schemaId, schemaVersionId, "", "", status, "", ""))));
+        }
+
+        return answer.andThenTo(state -> {
+            if (status.toLowerCase().equals(state.status.value.toLowerCase()))
+                return Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state))));
+            else
+                return Completes.withSuccess(Response.of(
+                        Conflict,
+                        "Status '" + status + "' cannot be reached from current status '" + state.status.value + "'"));
+        });
+    }
+
+    public Completes<Response> querySchemaVersions(final String organizationId, final String unitId, final String contextId, final String schemaId) {
+        return Queries.forSchemaVersions()
+                .schemaVersions(organizationId, unitId, contextId, schemaId)
+                .andThenTo(schemaVersions -> Completes.withSuccess(Response.of(Ok, serialized(schemaVersions))));
     }
 
-    return SchemaVersion.with(stage, SchemaId.existing(organizationId, unitId, contextId, schemaId), Specification.of(data.specification), data.description, Version.of(data.previousVersion), Version.of(data.currentVersion))
-            .andThenTo(3000, state -> {
-                final String location = schemaVersionLocation(state.schemaVersionId);
-                final Headers<ResponseHeader> headers = Headers.of(
-                        of(Location, location),
-                        of(ContentType, "application/json; charset=UTF-8")
-                );
-                final String serialized = serialized(SchemaVersionData.from(state));
-
-                return Completes.withSuccess(Response.of(Created, headers, serialized));
-              })
-            .otherwise(response -> Response.of(Conflict, serialized(SchemaVersionData.from(organizationId, unitId, contextId, schemaId, NoId, data.specification, data.description, "Draft", data.previousVersion, data.currentVersion))));
-  }
-
-  public Completes<Response> describeAs(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String description) {
-    return commands
-              .describeAs(SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId), description).answer()
-              .andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
-  }
-
-  public Completes<Response> specifyWith(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String specification) {
-    if (!SchemaVersionData.hasSpecification(specification)) {
-      return Completes.withSuccess(Response.of(BadRequest, "Missing specification"));
+    public Completes<Response> querySchemaVersion(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId) {
+        return Queries.forSchemaVersions()
+                .schemaVersion(organizationId, unitId, contextId, schemaId, schemaVersionId)
+                .andThenTo(schemaVersion -> Completes.withSuccess(Response.of(Ok, serialized(schemaVersion))));
     }
 
-    return commands
-            .specifyWith(SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId), Specification.of(specification)).answer()
-            .andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
-  }
-
-  public Completes<Response> statusOf(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId, final String status) {
-    final SchemaVersionId id = SchemaVersionId.existing(organizationId, unitId, contextId, schemaId, schemaVersionId);
-    final Completes<SchemaVersionState> answer;
-
-    switch (status.toLowerCase()) {
-    case "published":
-      answer = commands.publish(id).answer();
-      break;
-    case "deprecated":
-      answer = commands.deprecate(id).answer();
-      break;
-    case "removed":
-      answer = commands.remove(id).answer();
-      break;
-    default:
-      return Completes.withSuccess(Response.of(Conflict, serialized(SchemaVersionData.from(organizationId, unitId, contextId, schemaId, schemaVersionId, "", "", status, "", ""))));
+    @Override
+    public Resource<?> routes() {
+        return resource("SchemaVersion Resource", 1,
+                post("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .body(SchemaVersionData.class)
+                        .handle(this::defineWith),
+                patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/description")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .body(String.class)
+                        .handle(this::describeAs),
+                patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/specification")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .body(String.class)
+                        .handle(this::specifyWith),
+                patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/status")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .body(String.class)
+                        .handle(this::statusOf),
+                get("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .handle(this::querySchemaVersions),
+                get("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}")
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .param(String.class)
+                        .handle(this::querySchemaVersion));
     }
 
-    return answer.andThenTo(state -> Completes.withSuccess(Response.of(Ok, serialized(SchemaVersionData.from(state)))));
-  }
-
-  public Completes<Response> querySchemaVersions(final String organizationId, final String unitId, final String contextId, final String schemaId) {
-    return Queries.forSchemaVersions()
-            .schemaVersions(organizationId, unitId, contextId, schemaId)
-            .andThenTo(schemaVersions -> Completes.withSuccess(Response.of(Ok, serialized(schemaVersions))));
-  }
-
-  public Completes<Response> querySchemaVersion(final String organizationId, final String unitId, final String contextId, final String schemaId, final String schemaVersionId) {
-    return Queries.forSchemaVersions()
-            .schemaVersion(organizationId, unitId, contextId, schemaId, schemaVersionId)
-            .andThenTo(schemaVersion -> Completes.withSuccess(Response.of(Ok, serialized(schemaVersion))));
-  }
-
-  @Override
-  public Resource<?> routes() {
-    return resource("SchemaVersion Resource", 1,
-      post("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .body(SchemaVersionData.class)
-        .handle(this::defineWith),
-      patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/description")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .body(String.class)
-        .handle(this::describeAs),
-      patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/specification")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .body(String.class)
-        .handle(this::specifyWith),
-      patch("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}/status")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .body(String.class)
-        .handle(this::statusOf),
-      get("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .handle(this::querySchemaVersions),
-      get("/organizations/{organizationId}/units/{unitId}/contexts/{contextId}/schemas/{schemaId}/versions/{schemaVersionId}")
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .param(String.class)
-        .handle(this::querySchemaVersion));
-  }
-
-  private String schemaVersionLocation(final SchemaVersionId schemaVersionId) {
-    return String.format(SchemaVersionsPath, schemaVersionId.organizationId().value, schemaVersionId.unitId().value, schemaVersionId.contextId().value, schemaVersionId.schemaId.value, schemaVersionId.value);
-  }
+    private String schemaVersionLocation(final SchemaVersionId schemaVersionId) {
+        return String.format(SchemaVersionsPath, schemaVersionId.organizationId().value, schemaVersionId.unitId().value, schemaVersionId.contextId().value, schemaVersionId.schemaId.value, schemaVersionId.value);
+    }
 }
diff --git a/src/test/e2e/cypress/integration/browse-schemata.spec.ts b/src/test/e2e/cypress/integration/browse-schemata.spec.ts
index 9f653ca6..a6a5c586 100644
--- a/src/test/e2e/cypress/integration/browse-schemata.spec.ts
+++ b/src/test/e2e/cypress/integration/browse-schemata.spec.ts
@@ -65,7 +65,6 @@ describe('Schemata View Tests', function () {
         cy.selectOption('Schema', schema)
         cy.fillField('Previous Version', prevVersion)
         cy.fillField('Current Version', currentVersion)
-        cy.selectOption('Status', faker.random.arrayElement(['Draft', 'Published', 'Deprecated', 'Removed']))
         cy.fillEditor('#description-editor', desc)
         cy.fillEditor('#specification-editor', spec)
         cy.contains('button', 'Create').click()
@@ -93,93 +92,4 @@ describe('Schemata View Tests', function () {
         cy.contains('.v-window-item--active',desc)
 
     });
-
-    it('can update schema version specification', function () {
-        // Setup
-        let orgName = faker.company.companyName()
-        let unitName = faker.lorem.word()
-        let namespace = faker.internet.domainName()
-        let schema = faker.company.catchPhraseNoun()
-        let majorMinorVersion = faker.random.number(9) + '.' + faker.random.number(9)
-        let patchVersion = faker.random.number(9)
-        let prevVersion = majorMinorVersion + '.' + patchVersion
-        let currentVersion = majorMinorVersion + '.' + (patchVersion + 1)
-        let spec = 'event SalutationHappened {\n' +
-            '    type eventType'
-        let desc = faker.lorem.sentence()
-
-        // Create Entities
-        cy.visit('/#/organization')
-        cy.fillField('Name', orgName)
-        cy.fillField('Description', 'foo')
-        cy.contains('button', 'Create').click()
-        cy.contains('a', 'Create Unit').click()
-
-        cy.selectOption('Organization', orgName)
-        cy.fillField('Name', unitName)
-        cy.fillField('Description', 'foo')
-        cy.contains('button', 'Create').click()
-        cy.contains('a', 'Create Context').click()
-
-        cy.selectOption('Organization', orgName)
-        cy.selectOption('Unit', unitName)
-        cy.fillField('Namespace', namespace)
-        cy.fillField('Description', 'foo')
-        cy.contains('button', 'Create').click()
-        cy.contains('a', 'Create Schema').click()
-
-        cy.fieldContent('SchemaID').should('be.empty')
-        cy.selectOption('Organization', orgName)
-        cy.selectOption('Unit', unitName)
-        cy.selectOption('Context', namespace)
-        cy.fillField('Name', schema)
-        cy.selectOption('Category', faker.random.arrayElement(['Command', 'Data', 'Document', 'Envelope', 'Event', 'Unknown']))
-        cy.selectOption('Scope', faker.random.arrayElement(['Public', 'Private']))
-        cy.fillField('Description', faker.lorem.sentence())
-        cy.contains('button', 'Create').click()
-        cy.contains('a', 'Create Schema Version').click()
-
-        cy.fieldContent('SchemaVersionID').should('be.empty')
-        cy.selectOption('Organization', orgName)
-        cy.selectOption('Unit', unitName)
-        cy.selectOption('Context', namespace)
-        cy.selectOption('Schema', schema)
-        cy.fillField('Previous Version', prevVersion)
-        cy.fillField('Current Version', currentVersion)
-        cy.selectOption('Status', 'Draft')
-        cy.fillEditor('#description-editor', desc)
-        cy.fillEditor('#specification-editor', spec)
-        cy.contains('button', 'Create').click()
-
-        // Assert visibility in treeview
-        // Filter for Org
-        cy.visit("/#/schemata")
-            .fillField('Search', orgName)
-
-        // Expand Tree
-        cy.contains('.v-treeview-node__label', orgName).click()
-        cy.contains('.v-treeview-node__label', unitName).click()
-        cy.contains('.v-treeview-node__label', namespace).click()
-        cy.contains('.v-treeview-node__label', schema).click()
-
-        // Select version
-        cy.contains('.v-list-item__title', currentVersion).click()
-
-        // Change spec
-        cy.fillEditor('#specification-editor', 'foo bar baz')
-        cy.contains('button', 'Save').click()
-
-        // Reload and navigate to schema version
-        cy.reload()
-        cy.visit("/#/schemata")
-            .fillField('Search', orgName)
-        cy.contains('.v-treeview-node__label', orgName).click()
-        cy.contains('.v-treeview-node__label', unitName).click()
-        cy.contains('.v-treeview-node__label', namespace).click()
-        cy.contains('.v-treeview-node__label', schema).click()
-        cy.contains('.v-list-item__title', currentVersion).click()
-
-        cy.editorContent('#specification-editor').should('contain','foo bar baz')
-    });
-
 });
\ No newline at end of file
diff --git a/src/test/e2e/cypress/integration/entity-creation.spec.ts b/src/test/e2e/cypress/integration/entity-creation.spec.ts
index 7c7414fd..5378f92b 100644
--- a/src/test/e2e/cypress/integration/entity-creation.spec.ts
+++ b/src/test/e2e/cypress/integration/entity-creation.spec.ts
@@ -133,7 +133,6 @@ describe('Entity Creation Tests', function () {
         cy.fieldContent('SchemaVersionID').should('be.empty')
         cy.fillField('Previous Version', prevVersion)
         cy.fillField('Current Version', currentVersion)
-        cy.selectOption('Status', faker.random.arrayElement(['Draft', 'Published', 'Deprecated', 'Removed']))
         cy.fillEditor('#description-editor', faker.lorem.sentence())
         cy.fillEditor('#specification-editor', 'event SalutationHappened {\n' +
             '    type eventType')
diff --git a/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts b/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts
new file mode 100644
index 00000000..2eb44928
--- /dev/null
+++ b/src/test/e2e/cypress/integration/schema-version-maintenance.spec.ts
@@ -0,0 +1,202 @@
+import * as faker from 'faker';
+
+describe('Schemata View Tests', function () {
+    before(() => {
+    });
+
+    after(() => {
+
+    });
+
+    beforeEach(() => {
+        cy.viewport(1280, 960)
+    });
+
+    it('can update schema version state', function () {
+        // Setup
+        let orgName = faker.company.companyName()
+        let unitName = faker.lorem.word()
+        let namespace = faker.internet.domainName()
+        let schema = faker.company.catchPhraseNoun()
+        let majorMinorVersion = faker.random.number(9) + '.' + faker.random.number(9)
+        let patchVersion = faker.random.number(9)
+        let prevVersion = majorMinorVersion + '.' + patchVersion
+        let currentVersion = majorMinorVersion + '.' + (patchVersion + 1)
+        let spec = 'event SalutationHappened {\n' +
+            '    type eventType'
+        let desc = faker.lorem.sentence()
+
+        // Create Entities
+        cy.visit('/#/organization')
+        cy.fillField('Name', orgName)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Unit').click()
+
+        cy.selectOption('Organization', orgName)
+        cy.fillField('Name', unitName)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Context').click()
+
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.fillField('Namespace', namespace)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Schema').click()
+
+        cy.fieldContent('SchemaID').should('be.empty')
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.selectOption('Context', namespace)
+        cy.fillField('Name', schema)
+        cy.selectOption('Category', faker.random.arrayElement(['Command', 'Data', 'Document', 'Envelope', 'Event', 'Unknown']))
+        cy.selectOption('Scope', faker.random.arrayElement(['Public', 'Private']))
+        cy.fillField('Description', faker.lorem.sentence())
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Schema Version').click()
+
+        cy.fieldContent('SchemaVersionID').should('be.empty')
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.selectOption('Context', namespace)
+        cy.selectOption('Schema', schema)
+        cy.fillField('Previous Version', prevVersion)
+        cy.fillField('Current Version', currentVersion)
+        cy.fillEditor('#description-editor', desc)
+        cy.fillEditor('#specification-editor', spec)
+        cy.contains('button', 'Create').click()
+
+        // Assert visibility in treeview
+        // Filter for Org
+        cy.visit("/#/schemata")
+            .fillField('Search', orgName)
+
+        // Expand Tree
+        cy.contains('.v-treeview-node__label', orgName).click()
+        cy.contains('.v-treeview-node__label', unitName).click()
+        cy.contains('.v-treeview-node__label', namespace).click()
+        cy.contains('.v-treeview-node__label', schema).click()
+
+        // Select version
+        cy.contains('.v-list-item__title', currentVersion).click()
+
+        // Assert all states reachable
+        cy.contains('button', 'Publish').should('be.enabled')
+        cy.contains('button', 'Deprecate').should('be.enabled')
+        cy.contains('button', 'Remove').should('be.enabled')
+        cy.get('.v-chip.warning')
+        cy.contains('button', 'Save').should('be.enabled')
+
+        //Publish
+        cy.contains('button', 'Publish').click()
+        cy.contains('button', 'Publish').should('be.disabled')
+        cy.contains('button', 'Deprecate').should('be.enabled')
+        cy.contains('button', 'Remove').should('be.disabled')
+        cy.contains('button', 'Save').should('be.disabled')
+
+        //Deprecate
+        cy.contains('button', 'Deprecate').click()
+        cy.contains('button', 'Publish').should('be.disabled')
+        cy.contains('button', 'Deprecate').should('be.disabled')
+        cy.contains('button', 'Remove').should('be.enabled')
+        cy.get('.v-chip.warning')
+        cy.contains('button', 'Save').should('be.disabled')
+
+        //Remove
+        cy.contains('button', 'Remove').click()
+        cy.contains('button', 'Publish').should('be.disabled')
+        cy.contains('button', 'Deprecate').should('be.disabled')
+        cy.contains('button', 'Remove').should('be.disabled')
+        cy.get('.v-chip.warning')
+        cy.contains('button', 'Save').should('be.disabled')
+    });
+
+    it('can update schema version specification', function () {
+        // Setup
+        let orgName = faker.company.companyName()
+        let unitName = faker.lorem.word()
+        let namespace = faker.internet.domainName()
+        let schema = faker.company.catchPhraseNoun()
+        let majorMinorVersion = faker.random.number(9) + '.' + faker.random.number(9)
+        let patchVersion = faker.random.number(9)
+        let prevVersion = majorMinorVersion + '.' + patchVersion
+        let currentVersion = majorMinorVersion + '.' + (patchVersion + 1)
+        let spec = 'event SalutationHappened {\n' +
+            '    type eventType'
+        let desc = faker.lorem.sentence()
+
+        // Create Entities
+        cy.visit('/#/organization')
+        cy.fillField('Name', orgName)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Unit').click()
+
+        cy.selectOption('Organization', orgName)
+        cy.fillField('Name', unitName)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Context').click()
+
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.fillField('Namespace', namespace)
+        cy.fillField('Description', 'foo')
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Schema').click()
+
+        cy.fieldContent('SchemaID').should('be.empty')
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.selectOption('Context', namespace)
+        cy.fillField('Name', schema)
+        cy.selectOption('Category', faker.random.arrayElement(['Command', 'Data', 'Document', 'Envelope', 'Event', 'Unknown']))
+        cy.selectOption('Scope', faker.random.arrayElement(['Public', 'Private']))
+        cy.fillField('Description', faker.lorem.sentence())
+        cy.contains('button', 'Create').click()
+        cy.contains('a', 'Create Schema Version').click()
+
+        cy.fieldContent('SchemaVersionID').should('be.empty')
+        cy.selectOption('Organization', orgName)
+        cy.selectOption('Unit', unitName)
+        cy.selectOption('Context', namespace)
+        cy.selectOption('Schema', schema)
+        cy.fillField('Previous Version', prevVersion)
+        cy.fillField('Current Version', currentVersion)
+        cy.fillEditor('#description-editor', desc)
+        cy.fillEditor('#specification-editor', spec)
+        cy.contains('button', 'Create').click()
+
+        // Assert visibility in treeview
+        // Filter for Org
+        cy.visit("/#/schemata")
+            .fillField('Search', orgName)
+
+        // Expand Tree
+        cy.contains('.v-treeview-node__label', orgName).click()
+        cy.contains('.v-treeview-node__label', unitName).click()
+        cy.contains('.v-treeview-node__label', namespace).click()
+        cy.contains('.v-treeview-node__label', schema).click()
+
+        // Select version
+        cy.contains('.v-list-item__title', currentVersion).click()
+
+        // Change spec
+        cy.fillEditor('#specification-editor', 'foo bar baz')
+        cy.contains('button', 'Save').click()
+
+        // Reload and navigate to schema version
+        cy.reload()
+        cy.visit("/#/schemata")
+            .fillField('Search', orgName)
+        cy.contains('.v-treeview-node__label', orgName).click()
+        cy.contains('.v-treeview-node__label', unitName).click()
+        cy.contains('.v-treeview-node__label', namespace).click()
+        cy.contains('.v-treeview-node__label', schema).click()
+        cy.contains('.v-list-item__title', currentVersion).click()
+
+        cy.editorContent('#specification-editor').should('contain','foo bar baz')
+    });
+});
\ No newline at end of file
diff --git a/src/test/e2e/cypress/integration/validation.spec.ts b/src/test/e2e/cypress/integration/validation.spec.ts
index d60835ce..eeed617b 100644
--- a/src/test/e2e/cypress/integration/validation.spec.ts
+++ b/src/test/e2e/cypress/integration/validation.spec.ts
@@ -72,8 +72,6 @@ describe('Form Validation Tests', function () {
         cy.contains('button', 'Create').should('be.disabled')
         cy.fillField('Current Version', currentVersion).get('.v-messages__message')
         cy.contains('button', 'Create').should('be.disabled')
-        cy.selectOption('Status', faker.random.arrayElement(['Draft', 'Published', 'Deprecated', 'Removed']))
-        cy.contains('button', 'Create').should('be.disabled')
         cy.fillEditor('#description-editor', faker.lorem.sentence())
         cy.contains('button', 'Create').should('be.disabled')
         cy.fillEditor('#specification-editor', 'event SalutationHappened {\n' +
diff --git a/src/test/java/io/vlingo/schemata/infra/persistence/SchemataObjectStoreTest.java b/src/test/java/io/vlingo/schemata/infra/persistence/SchemataObjectStoreTest.java
index 93b70490..c950981c 100644
--- a/src/test/java/io/vlingo/schemata/infra/persistence/SchemataObjectStoreTest.java
+++ b/src/test/java/io/vlingo/schemata/infra/persistence/SchemataObjectStoreTest.java
@@ -23,6 +23,7 @@
 import io.vlingo.symbio.store.object.MapQueryExpression;
 import io.vlingo.symbio.store.object.ObjectStore;
 import io.vlingo.symbio.store.object.ObjectStoreReader.QueryMode;
+import io.vlingo.symbio.store.object.StateSources;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Ignore;
@@ -57,7 +58,7 @@ public void testThatObjectStoreInsertsOrganizationStateAndQuerys() {
                 .from(orgId)
                 .defineWith(orgName, "Organization Vlingo");
 
-        objectStore.persist(organizationState, persistInterest);
+        objectStore.persist(StateSources.of(organizationState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -89,7 +90,7 @@ public void testThatObjectStoreInsertsOrganizationStateAndQuerys() {
         final OrganizationState updatedOrganizationState =
                 insertedOrganizationState.withDescription("Organization Vlingo V2");
 
-        objectStore.persist(updatedOrganizationState, persistInterest);
+        objectStore.persist(StateSources.of(updatedOrganizationState), persistInterest);
         querySelect(queryInterest, OrganizationState.class, "TBL_ORGANIZATIONS", "organizationId", orgId.value);
 
 
@@ -112,7 +113,7 @@ public void testThatObjectStoreInsertsUnitStateAndQuerys() {
                 .from(unitId)
                 .defineWith("Vlingo", "Unit Vlingo");
 
-        objectStore.persist(unitState, persistInterest);
+        objectStore.persist(StateSources.of(unitState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -130,7 +131,7 @@ public void testThatObjectStoreInsertsUnitStateAndQuerys() {
         final UnitState updatedUnitState =
                 insertedUnitState.defineWith("VlingoV2", "Unit Vlingo V2");
 
-        objectStore.persist(updatedUnitState, persistInterest);
+        objectStore.persist(StateSources.of(updatedUnitState), persistInterest);
         querySelect(queryInterest, UnitState.class, "TBL_UNITS", "unitId", unitId.value);
 
         queryInterest.until.completes();
@@ -152,7 +153,7 @@ public void testThatObjectStoreInsertsContextStateAndQuerys() {
                 .from(contextId)
                 .defineWith("io.vlingo", "Context Vlingo");
 
-        objectStore.persist(contextState, persistInterest);
+        objectStore.persist(StateSources.of(contextState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -170,7 +171,7 @@ public void testThatObjectStoreInsertsContextStateAndQuerys() {
         final ContextState updatedContextState =
                 insertedContextState.defineWith("io.vlingoV2", "Context Vlingo V2");
 
-        objectStore.persist(updatedContextState, persistInterest);
+        objectStore.persist(StateSources.of(updatedContextState), persistInterest);
         querySelect(queryInterest, ContextState.class, "TBL_CONTEXTS", "contextId", contextId.value);
 
         queryInterest.until.completes();
@@ -195,7 +196,7 @@ public void testThatObjectStoreInsertsSchemaStateAndQuerys() {
         final SchemaState schemaState = SchemaState.from(schemaId)
                 .defineWith(Category.Event, Scope.Public, "Vlingo", "Schema Vlingo");
 
-        objectStore.persist(schemaState, persistInterest);
+        objectStore.persist(StateSources.of(schemaState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -219,7 +220,7 @@ public void testThatObjectStoreInsertsSchemaStateAndQuerys() {
         final SchemaState updatedSchemaState =
                 insertedSchemaState.defineWith(Category.Document, Scope.Public, "VlingoV2", "Schema Vlingo V2");
 
-        objectStore.persist(updatedSchemaState, persistInterest);
+        objectStore.persist(StateSources.of(updatedSchemaState), persistInterest);
         querySelect(queryInterest, SchemaState.class, "TBL_SCHEMAS", "schemaId", schemaId.value);
 
         queryInterest.until.completes();
@@ -246,7 +247,7 @@ public void testThatObjectStoreInsertsSchemaVersionStateAndQuerys() {
                         Version.of("0.0.0"),
                         Version.of("1.0.0"));
 
-        objectStore.persist(schemaVersionState, persistInterest);
+        objectStore.persist(StateSources.of(schemaVersionState), persistInterest);
         final Outcome<StorageException, Result> outcome = access.readFrom("outcome");
         assertEquals(Result.Success, outcome.andThen(success -> success).get());
 
@@ -264,7 +265,7 @@ public void testThatObjectStoreInsertsSchemaVersionStateAndQuerys() {
         final SchemaVersionState updatedSchemaVersionState =
                 insertedSchemaVersionState.defineWith("Schema Version Vlingo V2", Specification.of("SpecV2"), Version.of("1.0.0"), Version.of("2.0.0"));
 
-        objectStore.persist(updatedSchemaVersionState, persistInterest);
+        objectStore.persist(StateSources.of(updatedSchemaVersionState), persistInterest);
         querySelect(queryInterest, SchemaVersionState.class, "TBL_SCHEMAVERSIONS", "schemaVersionId", schemaVersionId.value);
 
         queryInterest.until.completes();
diff --git a/src/test/java/io/vlingo/schemata/resource/SchemaVersionResourceTest.java b/src/test/java/io/vlingo/schemata/resource/SchemaVersionResourceTest.java
index 6ea3d0c7..83d76079 100644
--- a/src/test/java/io/vlingo/schemata/resource/SchemaVersionResourceTest.java
+++ b/src/test/java/io/vlingo/schemata/resource/SchemaVersionResourceTest.java
@@ -7,201 +7,226 @@
 
 package io.vlingo.schemata.resource;
 
-import static io.vlingo.http.Response.Status.BadRequest;
-import static io.vlingo.http.Response.Status.Created;
-import static io.vlingo.http.ResponseHeader.Location;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
 import io.vlingo.common.serialization.JsonSerialization;
 import io.vlingo.http.Response;
+import io.vlingo.schemata.model.Id;
 import io.vlingo.schemata.model.SchemaVersion.Status;
 import io.vlingo.schemata.resource.data.SchemaVersionData;
+import org.junit.Test;
+
+import static io.vlingo.http.Response.Status.BadRequest;
+import static io.vlingo.http.Response.Status.Created;
+import static io.vlingo.http.ResponseHeader.Location;
+import static org.junit.Assert.*;
 
 public class SchemaVersionResourceTest extends ResourceTest {
-  private static final String OrgId = "O123";
-  private static final String UnitId = "U456";
-  private static final String ContextId = "C789";
-  private static final String SchemaId = "S135";
-  private static final String SchemaVersionDescription = "Test context.";
-  private static final String SchemaVersionSpecification = "{ spec = \"spec\" ";
-  private static final String SchemaVersionStatus = "Draft";
-  private static final String SchemaVersionVersion000 = "0.0.0";
-  private static final String SchemaVersionVersion100 = "1.0.0";
-  private static final String SchemaVersionVersion101 = "1.0.1";
-  private static final String SchemaVersionVersion300 = "3.0.0";
-
-  @Test
-  public void testThatSchemaVersionIsDefined() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    assertNotNull(response1.headers.headerOf(Location));
-    final SchemaVersionData data = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    assertEquals(SchemaVersionStatus, data.status);
-    assertEquals(SchemaVersionSpecification, data.specification);
-    assertEquals(SchemaVersionDescription, data.description);
-    assertEquals(SchemaVersionVersion100, data.currentVersion);
-  }
-
-  @Test
-  public void testThatSchemaVersionMinorUpgradeIsDefined() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion101);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    assertNotNull(response1.headers.headerOf(Location));
-    final SchemaVersionData data = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    assertEquals(SchemaVersionStatus, data.status);
-    assertEquals(SchemaVersionSpecification, data.specification);
-    assertEquals(SchemaVersionDescription, data.description);
-    assertEquals(SchemaVersionVersion101, data.currentVersion);
-  }
-
-  @Test
-  public void testSchemaVersionDescribedAs() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    final Response response2 = resource.describeAs(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, SchemaVersionDescription + 1).await();
-    assertNotEquals(response1.entity.content(), response2.entity.content());
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(data1.description, data2.description);
-    assertEquals((SchemaVersionDescription + 1), data2.description);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsPublished() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
-    assertNotEquals(response1.entity.content(), response2.entity.content());
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(data1.status, data2.status);
-    assertEquals(Status.Published.name(), data2.status);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsDeprecated() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
-    assertNotEquals(response1.entity.content(), response2.entity.content());
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(data1.status, data2.status);
-    assertEquals(Status.Deprecated.name(), data2.status);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsNotDeprecated() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
-    assertEquals(response1.entity.content(), response2.entity.content());
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertEquals(data1.status, data2.status);
-    assertNotEquals(Status.Deprecated.name(), data2.status);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsRemoved() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
-    resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Removed.name()).await();
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(data1.status, data2.status);
-    assertEquals(Status.Removed.name(), data2.status);
-  }
-
-  @Test
-  public void testThatSchemaVersionIsNotRemoved() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(Created, response1.status);
-    final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
-    resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
-    final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Removed.name()).await();
-    final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
-    assertEquals(data1.schemaVersionId, data2.schemaVersionId);
-    assertNotEquals(Status.Removed.name(), data2.status);
-  }
-
-  @Test
-  public void testFailDefineWithNullSpecification() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(null, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("missing"));
-    assertNull(response1.headers.headerOf(Location));
-  }
-
-  @Test
-  public void testFailDefineWithEmptySpecification() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just("", SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("missing"));
-    assertNull(response1.headers.headerOf(Location));
-  }
-
-  @Test
-  public void testFailDefineWithZeroVersions() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion000);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
-    assertNull(response1.headers.headerOf(Location));
-  }
-
-  @Test
-  public void testFailDefineWithHighLowVersions() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion000);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
-    assertNull(response1.headers.headerOf(Location));
-  }
-
-  @Test
-  public void testFailDefineWithGappedVersions() {
-    final SchemaVersionResource resource = new SchemaVersionResource(world);
-    final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion300);
-    final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
-    assertEquals(BadRequest, response1.status);
-    assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
-    assertNull(response1.headers.headerOf(Location));
-  }
+    private static final String OrgId = "O123";
+    private static final String UnitId = "U456";
+    private static final String ContextId = "C789";
+    private static final String SchemaId = "S135";
+    private static final String SchemaVersionDescription = "Test context.";
+    private static final String SchemaVersionSpecification = "{ spec = \"spec\" ";
+    private static final String SchemaVersionStatus = "Draft";
+    private static final String SchemaVersionVersion000 = "0.0.0";
+    private static final String SchemaVersionVersion100 = "1.0.0";
+    private static final String SchemaVersionVersion101 = "1.0.1";
+    private static final String SchemaVersionVersion300 = "3.0.0";
+
+    @Test
+    public void testThatSchemaVersionIsDefined() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        assertNotNull(response1.headers.headerOf(Location));
+        final SchemaVersionData data = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        assertEquals(SchemaVersionStatus, data.status);
+        assertEquals(SchemaVersionSpecification, data.specification);
+        assertEquals(SchemaVersionDescription, data.description);
+        assertEquals(SchemaVersionVersion100, data.currentVersion);
+    }
+
+    @Test
+    public void testThatSchemaVersionMinorUpgradeIsDefined() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion101);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        assertNotNull(response1.headers.headerOf(Location));
+        final SchemaVersionData data = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        assertEquals(SchemaVersionStatus, data.status);
+        assertEquals(SchemaVersionSpecification, data.specification);
+        assertEquals(SchemaVersionDescription, data.description);
+        assertEquals(SchemaVersionVersion101, data.currentVersion);
+    }
+
+    @Test
+    public void testSchemaVersionDescribedAs() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        final Response response2 = resource.describeAs(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, SchemaVersionDescription + 1).await();
+        assertNotEquals(response1.entity.content(), response2.entity.content());
+        final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(data1.description, data2.description);
+        assertEquals((SchemaVersionDescription + 1), data2.description);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsPublished() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
+        assertNotEquals(response1.entity.content(), response2.entity.content());
+        final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(data1.status, data2.status);
+        assertEquals(Status.Published.name(), data2.status);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsDeprecated() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
+        assertNotEquals(response1.entity.content(), response2.entity.content());
+        final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(data1.status, data2.status);
+        assertEquals(Status.Deprecated.name(), data2.status);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsNotDeprecated() {
+        Id.OrganizationId orgId = Id.OrganizationId.unique();
+        Id.UnitId unitId = Id.UnitId.uniqueFor(orgId);
+        Id.ContextId contextId = Id.ContextId.uniqueFor(unitId);
+        Id.SchemaId schemaId = Id.SchemaId.uniqueFor(contextId);
+
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(
+                orgId.value, unitId.value, contextId.value, schemaId.value, defineData)
+                .await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
+        assertEquals(Response.Status.Conflict, response2.status);
+        assertTrue(response2.entity.content().contains("Status 'Deprecated' cannot be reached from current status"));
+
+        Response responseAfterTriedUpdate =
+                resource.querySchemaVersion(orgId.value, unitId.value, contextId.value, schemaId.value, data1.schemaVersionId)
+                .await();
+
+        final SchemaVersionData data2 =
+                JsonSerialization.deserialized(responseAfterTriedUpdate.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertEquals(data1.status, data2.status);
+        assertNotEquals(Status.Deprecated.name(), data2.status);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsRemoved() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
+        resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Deprecated.name()).await();
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Removed.name()).await();
+        final SchemaVersionData data2 = JsonSerialization.deserialized(response2.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(data1.status, data2.status);
+        assertEquals(Status.Removed.name(), data2.status);
+    }
+
+    @Test
+    public void testThatSchemaVersionIsNotRemoved() {
+        Id.OrganizationId orgId = Id.OrganizationId.unique();
+        Id.UnitId unitId = Id.UnitId.uniqueFor(orgId);
+        Id.ContextId contextId = Id.ContextId.uniqueFor(unitId);
+        Id.SchemaId schemaId = Id.SchemaId.uniqueFor(contextId);
+
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 =
+                resource.defineWith(orgId.value, unitId.value, contextId.value, schemaId.value, defineData)
+                        .await();
+        assertEquals(Created, response1.status);
+        final SchemaVersionData data1 = JsonSerialization.deserialized(response1.entity.content(), SchemaVersionData.class);
+        resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Published.name()).await();
+        final Response response2 = resource.statusOf(data1.organizationId, data1.unitId, data1.contextId, data1.schemaId, data1.schemaVersionId, Status.Removed.name()).await();
+        assertEquals(Response.Status.Conflict, response2.status);
+
+        Response responseAfterTriedUpdate =
+                resource.querySchemaVersion(orgId.value, unitId.value, contextId.value, schemaId.value, data1.schemaVersionId)
+                        .await();
+
+        final SchemaVersionData data2 =
+                JsonSerialization.deserialized(responseAfterTriedUpdate.entity.content(), SchemaVersionData.class);
+        assertEquals(data1.schemaVersionId, data2.schemaVersionId);
+        assertNotEquals(Status.Removed.name(), data2.status);
+    }
+
+    @Test
+    public void testFailDefineWithNullSpecification() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(null, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("missing"));
+        assertNull(response1.headers.headerOf(Location));
+    }
+
+    @Test
+    public void testFailDefineWithEmptySpecification() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just("", SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion100);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("missing"));
+        assertNull(response1.headers.headerOf(Location));
+    }
+
+    @Test
+    public void testFailDefineWithZeroVersions() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion000, SchemaVersionVersion000);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
+        assertNull(response1.headers.headerOf(Location));
+    }
+
+    @Test
+    public void testFailDefineWithHighLowVersions() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion000);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
+        assertNull(response1.headers.headerOf(Location));
+    }
+
+    @Test
+    public void testFailDefineWithGappedVersions() {
+        final SchemaVersionResource resource = new SchemaVersionResource(world);
+        final SchemaVersionData defineData = SchemaVersionData.just(SchemaVersionSpecification, SchemaVersionDescription, "", SchemaVersionVersion100, SchemaVersionVersion300);
+        final Response response1 = resource.defineWith(OrgId, UnitId, ContextId, SchemaId, defineData).await();
+        assertEquals(BadRequest, response1.status);
+        assertTrue(response1.entity.content().toLowerCase().contains("conflicting"));
+        assertNull(response1.headers.headerOf(Location));
+    }
 }