diff --git a/ui/src/app/metadata/Metadata.js b/ui/src/app/metadata/Metadata.js
index dc00b0e7f..a9ff0b182 100644
--- a/ui/src/app/metadata/Metadata.js
+++ b/ui/src/app/metadata/Metadata.js
@@ -10,6 +10,7 @@ import { MetadataXml } from './view/MetadataXml';
 import { MetadataComparison } from './view/MetadataComparison';
 import { MetadataVersion } from './view/MetadataVersion';
 import { MetadataEdit } from './view/MetadataEdit';
+import { MetadataRestore } from './view/MetadataRestore';
 
 export function Metadata () {
 
@@ -50,6 +51,9 @@ export function Metadata () {
                             <Route path={`${path}/edit/:section`} render={ () =>
                                 <MetadataEdit />
                             } />
+                            <Route path={`${path}/restore/:versionId/:section`} render={ () =>
+                                <MetadataRestore />
+                            } />
                             <Redirect exact path={`${path}`} to={`${path}/configuration/options`} />
                         </Switch>
                     </MetadataSchema>
diff --git a/ui/src/app/metadata/editor/MetadataEditor.js b/ui/src/app/metadata/editor/MetadataEditor.js
index 7ea1632cc..1290d07c1 100644
--- a/ui/src/app/metadata/editor/MetadataEditor.js
+++ b/ui/src/app/metadata/editor/MetadataEditor.js
@@ -16,21 +16,18 @@ import { NavLink } from 'react-router-dom';
 import { useTranslator } from '../../i18n/hooks';
 import API_BASE_PATH from '../../App.constant';
 
-export function MetadataEditor () {
+export function MetadataEditor ({ current }) {
 
     const translator = useTranslator();
 
     const { type, id, section } = useParams();
 
-    const current = useMetadataObject();
-
     const { update, loading } = useMetadataUpdater(`${ API_BASE_PATH }${getMetadataPath(type)}`, current);
 
     const { data } = useMetadataEntities(type, {}, []);
     const history = useHistory();
     const definition = React.useContext(MetadataDefinitionContext);
     const schema = React.useContext(MetadataSchemaContext);
-    
 
     const { state, dispatch } = React.useContext(MetadataFormContext);
     const { metadata, errors } = state;
diff --git a/ui/src/app/metadata/hoc/MetadataSelector.js b/ui/src/app/metadata/hoc/MetadataSelector.js
index 5efd8e460..7d7155066 100644
--- a/ui/src/app/metadata/hoc/MetadataSelector.js
+++ b/ui/src/app/metadata/hoc/MetadataSelector.js
@@ -4,7 +4,6 @@ import { useMetadataEntity } from '../hooks/api';
 
 export const MetadataTypeContext = React.createContext();
 export const MetadataObjectContext = React.createContext();
-export const MetadataLoaderContext = React.createContext();
 
 /*eslint-disable react-hooks/exhaustive-deps*/
 export function MetadataSelector({ children, ...props }) {
@@ -34,16 +33,12 @@ export function MetadataSelector({ children, ...props }) {
     }
     React.useEffect(() => { loadMetadata(id) }, [id]);
 
-    const update = () => loadMetadata(id);
-
     return (
         <>
         {type &&
             <MetadataTypeContext.Provider value={type}>
                 {metadata && metadata.version &&
-                <MetadataLoaderContext.Provider value={{ load: update }}>
                     <MetadataObjectContext.Provider value={metadata}>{children(metadata)}</MetadataObjectContext.Provider>
-                </MetadataLoaderContext.Provider>
                 }
             </MetadataTypeContext.Provider>
         }
@@ -55,8 +50,4 @@ export function useMetadataObject () {
     return React.useContext(MetadataObjectContext);
 }
 
-export function useMetadataLoader () {
-    return React.useContext(MetadataLoaderContext);
-}
-
 export default MetadataSelector;
\ No newline at end of file
diff --git a/ui/src/app/metadata/hoc/MetadataVersionLoader.js b/ui/src/app/metadata/hoc/MetadataVersionLoader.js
index 40b6f2bdf..b14e0f59a 100644
--- a/ui/src/app/metadata/hoc/MetadataVersionLoader.js
+++ b/ui/src/app/metadata/hoc/MetadataVersionLoader.js
@@ -1,49 +1,38 @@
 import React from 'react';
-import { useParams } from 'react-router';
-import { getMetadataPath } from '../hooks/api';
-import API_BASE_PATH from '../../App.constant';
-import useFetch from 'use-http';
-import { last } from 'lodash';
+import { useParams } from 'react-router-dom';
+import { useMetadataEntity } from '../hooks/api';
 
-export function MetadataVersionLoader ({versions, children}) {
+export const MetadataVersionContext = React.createContext();
 
-    const ref = React.useRef({});
-    const [list, setList] = React.useState({});
+const { Provider } = MetadataVersionContext;
 
-    const { type, id } = useParams();
+export function MetadataVersionLoader({children}) {
 
-    const { get, response } = useFetch(`/${API_BASE_PATH}${getMetadataPath(type)}/${id}/Versions`, {
+    const { type, id, versionId } = useParams();
+
+    const [metadata, setMetadata] = React.useState();
+
+    const { get, response } = useMetadataEntity(type, {
         cachePolicy: 'no-cache',
     }, []);
 
     async function loadVersion(v) {
-        const l = await get(`/${v}`);
+        const l = await get(`/${id}/Versions/${v}`);
         if (response.ok) {
-            addToList(v, l);
-            if (last(versions) !== v) {
-                loadNext(versions[versions.indexOf(v) + 1]);
-            }
+            setMetadata(l);
         }
     }
 
-    function addToList(version, item) {
-        ref.current = {
-            ...ref.current,
-            [version]: item
-        };
-        setList(ref.current);
-    }
-
-    function loadNext (v) {
-        loadVersion(v);
-    }
-
     /*eslint-disable react-hooks/exhaustive-deps*/
     React.useEffect(() => {
-        loadNext(versions[0]);
-    }, [versions]);
+        loadVersion(versionId);
+    }, [versionId]);
 
-    return (<React.Fragment>
-        {children(versions.map(v => list[v]).filter(v => !!v))}
-    </React.Fragment>);
-}
\ No newline at end of file
+    return (
+        <>
+            {metadata &&
+                <Provider value={metadata}>{children(metadata)}</Provider>
+            }
+        </>
+    );
+}
diff --git a/ui/src/app/metadata/hoc/MetadataVersionsLoader.js b/ui/src/app/metadata/hoc/MetadataVersionsLoader.js
new file mode 100644
index 000000000..025cea743
--- /dev/null
+++ b/ui/src/app/metadata/hoc/MetadataVersionsLoader.js
@@ -0,0 +1,49 @@
+import React from 'react';
+import { useParams } from 'react-router';
+import { getMetadataPath } from '../hooks/api';
+import API_BASE_PATH from '../../App.constant';
+import useFetch from 'use-http';
+import { last } from 'lodash';
+
+export function MetadataVersionsLoader ({versions, children}) {
+
+    const ref = React.useRef({});
+    const [list, setList] = React.useState({});
+
+    const { type, id } = useParams();
+
+    const { get, response } = useFetch(`/${API_BASE_PATH}${getMetadataPath(type)}/${id}/Versions`, {
+        cachePolicy: 'no-cache',
+    }, []);
+
+    async function loadVersion(v) {
+        const l = await get(`/${v}`);
+        if (response.ok) {
+            addToList(v, l);
+            if (last(versions) !== v) {
+                loadNext(versions[versions.indexOf(v) + 1]);
+            }
+        }
+    }
+
+    function addToList(version, item) {
+        ref.current = {
+            ...ref.current,
+            [version]: item
+        };
+        setList(ref.current);
+    }
+
+    function loadNext (v) {
+        loadVersion(v);
+    }
+
+    /*eslint-disable react-hooks/exhaustive-deps*/
+    React.useEffect(() => {
+        loadNext(versions[0]);
+    }, [versions]);
+
+    return (<React.Fragment>
+        {children(versions.map(v => list[v]).filter(v => !!v))}
+    </React.Fragment>);
+}
\ No newline at end of file
diff --git a/ui/src/app/metadata/view/MetadataComparison.js b/ui/src/app/metadata/view/MetadataComparison.js
index 566787a55..05bfe6d82 100644
--- a/ui/src/app/metadata/view/MetadataComparison.js
+++ b/ui/src/app/metadata/view/MetadataComparison.js
@@ -5,7 +5,7 @@ import {
     withDefault
 } from 'use-query-params';
 import { MetadataDefinitionContext, MetadataSchemaContext } from '../hoc/MetadataSchema';
-import { MetadataVersionLoader } from '../hoc/MetadataVersionLoader';
+import { MetadataVersionsLoader } from '../hoc/MetadataVersionsLoader';
 import { Configuration } from '../hoc/Configuration';
 import { MetadataConfiguration } from '../component/MetadataConfiguration';
 import { Link, useParams } from 'react-router-dom';
@@ -40,7 +40,7 @@ export function MetadataComparison () {
             &nbsp;Configuration
         </h2>
         {versions &&
-        <MetadataVersionLoader versions={versions}>
+        <MetadataVersionsLoader versions={versions}>
             {(v) =>
                 <Configuration entities={v} schema={processed} definition={definition} limited={limited}>
                         {(config) => 
@@ -77,7 +77,7 @@ export function MetadataComparison () {
                         }
                 </Configuration>
             }
-        </MetadataVersionLoader>
+        </MetadataVersionsLoader>
         }
         </>
     );
diff --git a/ui/src/app/metadata/view/MetadataEdit.js b/ui/src/app/metadata/view/MetadataEdit.js
index a3ff4d7e9..45d326312 100644
--- a/ui/src/app/metadata/view/MetadataEdit.js
+++ b/ui/src/app/metadata/view/MetadataEdit.js
@@ -9,7 +9,7 @@ export function MetadataEdit() {
 
     return (
         <MetadataForm initial={base}>
-            <MetadataEditor />
+            <MetadataEditor current={base} />
         </MetadataForm>
     );
 }
\ No newline at end of file
diff --git a/ui/src/app/metadata/view/MetadataHistory.js b/ui/src/app/metadata/view/MetadataHistory.js
index 2bd83db69..886c1e201 100644
--- a/ui/src/app/metadata/view/MetadataHistory.js
+++ b/ui/src/app/metadata/view/MetadataHistory.js
@@ -23,7 +23,9 @@ export function MetadataHistory () {
 
     const history = useHistory();
 
-    const { data, loading } = useMetadataHistory(type, id, {}, []);
+    const { data, loading } = useMetadataHistory(type, id, {
+        cachePolicy: 'no-cache'
+    }, []);
 
     const toggleVersionSelected = (version) => {
         let s = [...selected];
@@ -34,7 +36,6 @@ export function MetadataHistory () {
         }
         setSelected(s);
     };
-    const restore = () => {};
     const compare = (versions) => {
         const s = sortVersionsByDate(versions);
         const path = `/metadata/${type}/${id}/configuration/compare?${queryString.stringify({versions: s.map(s => s.id)}, {
@@ -96,10 +97,10 @@ export function MetadataHistory () {
                                 <td>{ version.creator }</td>
                                 <td>
                                     {i > 0 &&
-                                    <button className="btn btn-text btn-link" onClick={ () => restore(version) }>
+                                    <Link className="btn btn-text btn-link" to={`/metadata/${type}/${id}/restore/${version.id}/common`}>
                                         <FontAwesomeIcon icon={faUndo} />&nbsp;
                                         <Translate value="action.restore">Restore</Translate>
-                                    </button>
+                                    </Link>
                                     }
                                 </td>
                             </tr>
diff --git a/ui/src/app/metadata/view/MetadataRestore.js b/ui/src/app/metadata/view/MetadataRestore.js
new file mode 100644
index 000000000..9511c4c92
--- /dev/null
+++ b/ui/src/app/metadata/view/MetadataRestore.js
@@ -0,0 +1,26 @@
+import React from 'react';
+import { MetadataEditor } from '../editor/MetadataEditor';
+import { MetadataForm } from '../hoc/MetadataFormContext';
+import { useMetadataObject } from '../hoc/MetadataSelector';
+import { MetadataVersionLoader } from '../hoc/MetadataVersionLoader';
+
+export function MetadataRestore() {
+
+    const latest = useMetadataObject();
+
+    return (
+        <MetadataVersionLoader>
+            {(metadata) =>
+                <MetadataForm initial={{
+                    ...metadata,
+                    version: latest.version
+                }}>
+                    <MetadataEditor current={{
+                        ...metadata,
+                        version: latest.version
+                    }} />
+                </MetadataForm>
+            }
+        </MetadataVersionLoader>
+    );
+}
diff --git a/ui/src/app/metadata/view/MetadataVersion.js b/ui/src/app/metadata/view/MetadataVersion.js
index 4ae8263cc..9335bf563 100644
--- a/ui/src/app/metadata/view/MetadataVersion.js
+++ b/ui/src/app/metadata/view/MetadataVersion.js
@@ -10,41 +10,21 @@ import { faArrowUp, faHistory, faPlus } from '@fortawesome/free-solid-svg-icons'
 import { scroller } from 'react-scroll';
 
 import Translate from '../../i18n/components/translate';
-import { useMetadataEntity } from '../hooks/api';
 import { MetadataHeader } from '../component/MetadataHeader';
 import { MetadataFilters } from '../domain/filter/component/MetadataFilters';
 import { MetadataFilterConfigurationList } from '../domain/filter/component/MetadataFilterConfigurationList';
 import { MetadataFilterTypes } from '../domain/filter';
 import { useMetadataSchema } from '../hooks/schema';
-
+import { MetadataVersionLoader } from '../hoc/MetadataVersionLoader';
 
 export function MetadataVersion() {
 
-    const { type, id, versionId } = useParams();
-
-    const [metadata, setMetadata] = React.useState();
+    const { type, id } = useParams();
 
     const schema = React.useContext(MetadataSchemaContext);
     const definition = React.useContext(MetadataDefinitionContext);
-
     const processed = useMetadataSchema(definition, schema);
 
-    const { get, response } = useMetadataEntity(type, {
-        cachePolicy: 'no-cache',
-    }, []);
-
-    async function loadVersion(v) {
-        const l = await get(`/${id}/Versions/${v}`);
-        if (response.ok) {
-            setMetadata(l);
-        }
-    }
-
-    /*eslint-disable react-hooks/exhaustive-deps*/
-    React.useEffect(() => {
-        loadVersion(versionId);
-    }, [versionId]);
-
     const onScrollTo = (element, offset = 0) => {
         scroller.scrollTo(element, {
             duration: 500,
@@ -54,8 +34,8 @@ export function MetadataVersion() {
     };
 
     return (
-        <>
-            {metadata &&
+        <MetadataVersionLoader>
+            {(metadata) =>
                 <Configuration entities={[metadata]} schema={processed} definition={definition}>
                     {(config) =>
                         <>
@@ -108,6 +88,6 @@ export function MetadataVersion() {
                     }
                 </Configuration>
             }
-        </>
+        </MetadataVersionLoader>
     );
 }